Updated the documentation to describe the visualizer, made unit-trace itself not require gtk/cairo, and a few other minor things.

10 files changed, 980 insertions, 747 deletions

diff --git a/unit_trace/viz/__init__.py b/unit_trace/viz/__init__.py
index 8ba4784..99ed99e 100644
--- a/unit_trace/viz/__init__.py
+++ b/unit_trace/viz/__init__.py
@@ -1,10 +1,19 @@
-import visualizer
-import viewer
-import renderer
-import format
-import gobject
-import gtk
-import convert
+try:
+    import pygtk
+    import gtk
+    import gobject
+    import cairo
+    import visualizer
+    import viewer
+    import renderer
+    import format
+    import convert
+except ImportError:
+    import sys
+
+    print 'Unit-Trace could not find pycairo and/or pygtk installed on your system. Please\n' \
+            + 'make sure these libraries are installed before attempting to use the visualizer.'
+    sys.exit(1)
 
 gobject.signal_new('set-scroll-adjustments', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
                         None, (gtk.Adjustment, gtk.Adjustment))
diff --git a/unit_trace/viz/canvas.py b/unit_trace/viz/canvas.py
index 758dea3..ea73d98 100644
--- a/unit_trace/viz/canvas.py
+++ b/unit_trace/viz/canvas.py
@@ -33,19 +33,19 @@ class Surface(object):
         self.scale = 1.0
         self.fname = fname
         self.ctx = ctx
-    
+
     def renew(self, width, height):
         raise NotImplementedError
-    
+
     def change_ctx(self, ctx):
         self.ctx = ctx
-            
+
     def get_fname(self):
         return self.fname
-        
+
     def write_out(self, fname):
         raise NotImplementedError
-        
+
     def pan(self, x, y, width, height):
         """A surface actually represents just a ``window'' into
         what we are drawing on. For instance, if we are scrolling through
@@ -57,11 +57,11 @@ class Surface(object):
         self.virt_y = y
         self.width = width
         self.height = height
-    
+
     def set_scale(self, scale):
         """Sets the scale factor."""
         self.scale = scale
-        
+
     def get_real_coor(self, x, y):
         """Translates the coordinates (x, y)
         in the ``theoretical'' plane to the true (x, y) coordinates on this surface
@@ -69,57 +69,57 @@ class Surface(object):
         bounds of the surface,
         if we want something outside the surface's ``window''."""
         return (x - self.virt_x * self.scale, y - self.virt_y * self.scale)
-    
+
     def get_virt_coor(self, x, y):
         """Does the inverse of the last method."""
         return (x + self.virt_x * self.scale, y + self.virt_y * self.scale)
-    
+
     def get_virt_coor_unscaled(self, x, y):
         """Does the same, but removes the scale factor (i.e. behaves as if
         the scale was 1.0 all along)."""
         return (x / self.scale + self.virt_x, y / self.scale + self.virt_y)
-            
+
 class SVGSurface(Surface):
     def renew(self, width, height):
         iwidth = int(math.ceil(width))
         iheight = int(math.ceil(height))
         self.surface = cairo.SVGSurface(self.fname, iwidth, iheight)
         self.ctx = cairo.Context(self.surface)
-        
+
     def write_out(self, fname):
         os.execl('cp', self.fname, fname)
-    
+
 class ImageSurface(Surface):
     def renew(self, width, height):
         iwidth = int(math.ceil(width))
         iheight = int(math.ceil(height))
         self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, iwidth, iheight)
         self.ctx = cairo.Context(self.surface)
-            
+
     def write_out(self, fname):
         if self.surface is None:
             raise ValueError('Don\'t own surface, can\'t write to to file')
-        
+
         self.surface.write_to_png(fname)
 
 class Pattern(object):
     DEF_STRIPE_SIZE = 10
     MAX_FADE_WIDTH = 250
-    
+
     def __init__(self, color_list, stripe_size=DEF_STRIPE_SIZE):
         self.color_list = color_list
         self.stripe_size = stripe_size
-         
+
     def render_on_canvas(self, canvas, x, y, width, height, fade=False):
         fade_span = min(width, Pattern.MAX_FADE_WIDTH)
-        
+
         if len(self.color_list) == 1:
             if fade:
                 canvas.fill_rect_fade(x, y, fade_span, height, (1.0, 1.0, 1.0), \
                     self.color_list[0])
             else:
                 canvas.fill_rect(x, y, width, height, self.color_list[0])
-            
+
             if width > Pattern.MAX_FADE_WIDTH:
                     canvas.fill_rect(x + Pattern.MAX_FADE_WIDTH, y, width - Pattern.MAX_FADE_WIDTH,
                                      height, self.color_list[0])
@@ -133,100 +133,100 @@ class Pattern(object):
                         min(self.stripe_size, bottom - y), (1.0, 1.0, 1.0), self.color_list[i])
                 else:
                     canvas.fill_rect(x, y, width, min(self.stripe_size, bottom - y), self.color_list[i])
-                
+
                 if width > Pattern.MAX_FADE_WIDTH:
                     canvas.fill_rect(x + Pattern.MAX_FADE_WIDTH, y, width - Pattern.MAX_FADE_WIDTH,
                                      min(self.stripe_size, bottom - y), self.color_list[i])
-                    
+
                 y += self.stripe_size
                 n += 1
-        
+
 class Canvas(object):
     """This is a basic class that stores and draws on a Cairo surface,
     using various primitives related to drawing a real-time graph (up-arrows,
     down-arrows, bars, ...).
-    
+
     This is the lowest-level representation (aside perhaps from the Cairo
     surface itself) of a real-time graph. It allows the user to draw
     primitives at certain locations, but for the most part does not know
     anything about real-time scheduling, just how to draw the basic parts
     that make up a schedule graph. For that, see Graph or its descendants."""
-    
+
     BOTTOM_LAYER = 0
     MIDDLE_LAYER = 1
     TOP_LAYER = 2
-    
+
     LAYERS = (BOTTOM_LAYER, MIDDLE_LAYER, TOP_LAYER)
-    
+
     NULL_PATTERN = -1
-    
+
     SQRT3 = math.sqrt(3.0)
-    
+
     def __init__(self, width, height, item_clist, bar_plist, surface):
         """Creates a new Canvas of dimensions (width, height). The
         parameters ``item_plist'' and ``bar_plist'' each specify a list
         of patterns to choose from when drawing the items on the y-axis
         or filling in bars, respectively."""
-        
+
         self.surface = surface
-        
+
         self.width = int(math.ceil(width))
         self.height = int(math.ceil(height))
         self.item_clist = item_clist
         self.bar_plist = bar_plist
-        
+
         self.selectable_regions = {}
-        
+
         self.scale = 1.0
 
     # clears the canvas.
     def clear(self):
         raise NotImplementedError
-    
+
     def set_scale(self, scale):
         self.scale = scale
         self.surface.set_scale(scale)
         for event in self.selectable_regions:
             self.selectable_regions[event].set_scale(scale)
-        
+
     def scaled(self, *coors):
         """Scales a series of coordinates."""
         return [coor * self.scale for coor in coors]
-    
+
     def unscaled(self, *coors):
         """Inverse of scale()."""
         return [coor / self.scale for coor in coors]
-        
+
     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, 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, snap=True):
         """Draws a rectangle somewhere, filled in with the fade."""
         raise NotImplementedError
-            
+
     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, 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, 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, snap=True):
         """Draws text at a position with a certain alignment."""
-        raise NotImplementedError   
-    
+        raise NotImplementedError
+
     def draw_label_with_sscripts(self, text, supscript, subscript, x, y, \
                                  textfopts=GraphFormat.DEF_FOPTS_LABEL,
                                  sscriptfopts=GraphFormat.DEF_FOPTS_LABEL_SSCRIPT, \
@@ -234,31 +234,31 @@ class Canvas(object):
         """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
-    
+
     def draw_y_axis(self, x, y, height):
         """Draws the y-axis, starting from the bottom at the point x, y."""
         self.surface.ctx.set_source_rgb(0.0, 0.0, 0.0)
-        
+
         self.draw_line((x, y), (x, y - height), (0.0, 0.0, 0.0), GraphFormat.AXIS_THICKNESS)
-        
+
     def draw_y_axis_labels(self, x, y, height, item_list, item_size, fopts=None):
         """Draws the item labels on the y-axis. ``item_list'' is the list
         of strings to print, while item_size gives the vertical amount of
         space that each item shall take up, in pixels."""
         if fopts is None:
             fopts = GraphFormat.DEF_FOPTS_ITEM
-        
+
         x -= GraphFormat.Y_AXIS_ITEM_GAP
         y -= height - item_size / 2.0
-        
+
         orig_color = fopts.color
         for ctr, item in enumerate(item_list):
             fopts.color = self.get_item_color(ctr)
             self.draw_label(item, x, y, fopts, AlignMode.RIGHT, AlignMode.CENTER)
             y += item_size
-        
+
         fopts.color = orig_color
-        
+
     def draw_x_axis(self, x, y, start_tick, end_tick, maj_sep, min_per_maj):
         """Draws the x-axis, including all the major and minor ticks (but not the labels).
         ``num_maj'' gives the number of major ticks, ``maj_sep'' the number of pixels between
@@ -271,48 +271,48 @@ class Canvas(object):
         for i in range(start_tick, end_tick + 1):
             self.draw_line((x, y), (x, y + GraphFormat.MAJ_TICK_SIZE),
                            (0.0, 0.0, 0.0), GraphFormat.AXIS_THICKNESS)
-            
+
             if (i < end_tick):
                 for j in range(0, min_per_maj):
                     self.draw_line((x, y), (x + maj_sep / min_per_maj, y),
                         (0.0, 0.0, 0.0), GraphFormat.AXIS_THICKNESS)
-                    
+
                     x += 1.0 * maj_sep / min_per_maj
                     if j < min_per_maj - 1:
                         self.draw_line((x, y), (x, y + GraphFormat.MIN_TICK_SIZE),
                         (0.0, 0.0, 0.0), GraphFormat.AXIS_THICKNESS)
-        
+
     def draw_x_axis_labels(self, x, y, start_tick, end_tick, maj_sep, min_per_maj, start=0, incr=1, show_min=False, \
                            majfopts=GraphFormat.DEF_FOPTS_MAJ, minfopts=GraphFormat.DEF_FOPTS_MIN):
         """Draws the labels for the x-axis. (x, y) should give the origin.
         how far down you want the text. ``incr'' gives the increment per major
         tick. ``start'' gives the value of the first tick. ``show_min'' specifies
         whether to draw labels at minor ticks."""
-            
+
         x += GraphFormat.X_AXIS_MEASURE_OFS + start_tick * maj_sep
         y += GraphFormat.X_AXIS_LABEL_GAP + GraphFormat.MAJ_TICK_SIZE
-        
+
         minincr = incr / (min_per_maj * 1.0)
-        
+
         cur = start * 1.0
-        
-        for i in range(start_tick, end_tick + 1):    
+
+        for i in range(start_tick, end_tick + 1):
             text = util.format_float(cur, 2)
             self.draw_label(text, x, y, majfopts, AlignMode.CENTER, AlignMode.TOP)
-            
+
             if (i < end_tick):
                 if show_min:
                     for j in range(0, min_per_maj):
                         x += 1.0 * maj_sep / min_per_maj
                         cur += minincr
                         text = util.format_float(cur, 2)
-                    
+
                         if j < min_per_maj - 1:
                             self.draw_label(text, x, y, minfopts, AlignMode.CENTER, AlignMode.TOP)
                 else:
                     x += maj_sep
                     cur += incr
-    
+
     def draw_grid(self, x, y, height, start_tick, end_tick, start_item, end_item, maj_sep, item_size, \
                   min_per_maj=None, show_min=False):
         """Draws a grid dividing along the item boundaries and the major ticks.
@@ -321,22 +321,22 @@ class Canvas(object):
         ``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:
             return
-            
+
         line_width = (end_tick - start_tick) * maj_sep
         line_height = (end_item - start_item) * item_size
-        
+
         origin = (x, y)
-        
+
         # draw horizontal lines first
-        x = origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + start_tick * maj_sep 
+        x = origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + start_tick * maj_sep
         y = origin[1] - height + start_item * item_size
         for i in range(start_item, end_item + 1):
             self.draw_line((x, y), (x + line_width, y), GraphFormat.GRID_COLOR, GraphFormat.GRID_THICKNESS)
             y += item_size
-        
-        x = origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + start_tick * maj_sep 
+
+        x = origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + start_tick * maj_sep
         y = origin[1] - height + start_item * item_size
-        
+
         if show_min:
             for i in range(0, (end_tick - start_tick) * min_per_maj + 1):
                 self.draw_line((x, y), (x, y + line_height), GraphFormat.GRID_COLOR, GraphFormat.GRID_THICKNESS)
@@ -345,222 +345,222 @@ class Canvas(object):
             for i in range(start_tick, end_tick + 1):
                 self.draw_line((x, y), (x, y + line_height), GraphFormat.GRID_COLOR, GraphFormat.GRID_THICKNESS)
                 x += maj_sep
-                          
+
     def draw_bar(self, x, y, width, height, n, clip_side, selected):
         """Draws a bar with a certain set of dimensions, using pattern ``n'' from the
         bar pattern list."""
-        
+
         color, thickness = {False : (GraphFormat.BORDER_COLOR, GraphFormat.BORDER_THICKNESS),
                             True : (GraphFormat.HIGHLIGHT_COLOR, GraphFormat.BORDER_THICKNESS * 2.0)}[selected]
-                            
+
         # use a pattern to be pretty
         self.get_bar_pattern(n).render_on_canvas(self, x, y, width, height, True)
-        
+
         self.draw_rect(x, y, width, height, color, thickness, clip_side)
-    
+
     def add_sel_bar(self, x, y, width, height, event):
         self.add_sel_region(SelectableRegion(x, y, width, height, event))
-        
+
     def draw_mini_bar(self, x, y, width, height, n, clip_side, selected):
         """Like the above, except it draws a miniature version. This is usually used for
         secondary purposes (i.e. to show jobs that _should_ have been running at a certain time).
-        
+
         Of course we don't enforce the fact that this is mini, since the user can pass in width
         and height (but the mini bars do look slightly different: namely the borders are a different
         color)"""
-        
+
         color, thickness = {False : (GraphFormat.LITE_BORDER_COLOR, GraphFormat.BORDER_THICKNESS),
                             True : (GraphFormat.HIGHLIGHT_COLOR, GraphFormat.BORDER_THICKNESS * 1.5)}[selected]
-        
+
         self.get_bar_pattern(n).render_on_canvas(self, x, y, width, height, True)
-        
+
         self.draw_rect(x, y, width, height, color, thickness, clip_side)
-        
+
     def add_sel_mini_bar(self, x, y, width, height, event):
         self.add_sel_region(SelectableRegion(x, y, width, height, event))
-                                
+
     def draw_completion_marker(self, x, y, height, selected):
         """Draws the symbol that represents a job completion, using a certain height."""
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
         self.draw_line((x - height * GraphFormat.TEE_FACTOR / 2.0, y),
                        (x + height * GraphFormat.TEE_FACTOR / 2.0, y),
                        color, GraphFormat.BORDER_THICKNESS)
         self.draw_line((x, y), (x, y + height), color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_completion_marker(self, x, y, height, event):
         self.add_sel_region(SelectableRegion(x - height * GraphFormat.TEE_FACTOR / 2.0, y,
             height * GraphFormat.TEE_FACTOR, height, event))
-                       
+
     def draw_release_arrow_big(self, x, y, height, selected):
         """Draws a release arrow of a certain height: (x, y) should give the top
         (northernmost point) of the arrow. The height includes the arrowhead."""
         big_arrowhead_height = GraphFormat.BIG_ARROWHEAD_FACTOR * height
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
         colors = [(1.0, 1.0, 1.0), color]
         draw_funcs = [self.__class__.fill_polyline, self.__class__.draw_polyline]
         for i in range(0, 2):
             color = colors[i]
             draw_func = draw_funcs[i]
-            
+
             draw_func(self, [(x, y), (x - big_arrowhead_height / Canvas.SQRT3, y + big_arrowhead_height), \
                        (x + big_arrowhead_height / Canvas.SQRT3, y + big_arrowhead_height), (x, y)], \
                        color, GraphFormat.BORDER_THICKNESS)
-        
+
         self.draw_line((x, y + big_arrowhead_height), (x, y + height), color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_release_arrow_big(self, x, y, height, event):
         self.add_sel_arrow_big(x, y, height, event)
-            
+
     def draw_deadline_arrow_big(self, x, y, height, selected):
         """Draws a release arrow: x, y should give the top (northernmost
         point) of the arrow. The height includes the arrowhead."""
         big_arrowhead_height = GraphFormat.BIG_ARROWHEAD_FACTOR * height
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
         colors = [(1.0, 1.0, 1.0), color]
         draw_funcs = [self.__class__.fill_polyline, self.__class__.draw_polyline]
         for i in range(0, 2):
             color = colors[i]
             draw_func = draw_funcs[i]
-            
+
             draw_func(self, [(x, y + height), (x - big_arrowhead_height / Canvas.SQRT3, \
                         y + height - big_arrowhead_height), \
                         (x + big_arrowhead_height / Canvas.SQRT3, \
                         y + height - big_arrowhead_height), \
                         (x, y + height)], color, GraphFormat.BORDER_THICKNESS)
-        
+
         self.draw_line((x, y), (x, y + height - big_arrowhead_height),
                        color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_deadline_arrow_big(self, x, y, height, event):
         self.add_sel_arrow_big(x, y, height, event)
-    
+
     def add_sel_arrow_big(self, x, y, height, event):
         big_arrowhead_height = GraphFormat.BIG_ARROWHEAD_FACTOR * height
-        
+
         self.add_sel_region(SelectableRegion(x - big_arrowhead_height / Canvas.SQRT3,
             y, 2.0 * big_arrowhead_height / Canvas.SQRT3, height, event))
-                        
+
     def draw_release_arrow_small(self, x, y, height, selected):
         """Draws a small release arrow (most likely coming off the x-axis, although
         this method doesn't enforce this): x, y should give the top of the arrow"""
         small_arrowhead_height = GraphFormat.SMALL_ARROWHEAD_FACTOR * height
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
-        
+
         self.draw_line((x, y), (x - small_arrowhead_height, y + small_arrowhead_height), \
                        color, GraphFormat.BORDER_THICKNESS)
         self.draw_line((x, y), (x + small_arrowhead_height, y + small_arrowhead_height), \
                        color, GraphFormat.BORDER_THICKNESS)
         self.draw_line((x, y), (x, y + height), color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_release_arrow_small(self, x, y, height, event):
         self.add_sel_arrow_small(x, y, height, event)
-        
+
     def draw_deadline_arrow_small(self, x, y, height, selected):
         """Draws a small deadline arrow (most likely coming off the x-axis, although
         this method doesn't enforce this): x, y should give the top of the arrow"""
         small_arrowhead_height = GraphFormat.SMALL_ARROWHEAD_FACTOR * height
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
-        
+
         self.draw_line((x, y), (x, y + height), color, GraphFormat.BORDER_THICKNESS)
         self.draw_line((x - small_arrowhead_height, y + height - small_arrowhead_height), \
                        (x, y + height), color, GraphFormat.BORDER_THICKNESS)
         self.draw_line((x + small_arrowhead_height, y + height - small_arrowhead_height), \
                        (x, y + height), color, GraphFormat.BORDER_THICKNESS)
-        
+
     def add_sel_deadline_arrow_small(self, x, y, height, event):
         self.add_sel_arrow_small(x, y, height, event)
-    
+
     def add_sel_arrow_small(self, x, y, height, event):
         small_arrowhead_height = GraphFormat.SMALL_ARROWHEAD_FACTOR * height
-        
+
         self.add_sel_region(SelectableRegion(x - small_arrowhead_height, y,
             small_arrowhead_height * 2.0, height, event))
-            
+
     def draw_suspend_triangle(self, x, y, height, selected):
         """Draws the triangle that marks a suspension. (x, y) gives the topmost (northernmost) point
         of the symbol."""
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
         colors = [(0.0, 0.0, 0.0), color]
-        
+
         draw_funcs = [self.__class__.fill_polyline, self.__class__.draw_polyline]
         for i in range(0, 2):
             color = colors[i]
             draw_func = draw_funcs[i]
             draw_func(self, [(x, y), (x + height / 2.0, y + height / 2.0), (x, y + height), (x, y)], \
                       color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_suspend_triangle(self, x, y, height, event):
         self.add_sel_region(SelectableRegion(x, y, height / 2.0, height, event))
-        
+
     def draw_resume_triangle(self, x, y, height, selected):
         """Draws the triangle that marks a resumption. (x, y) gives the topmost (northernmost) point
         of the symbol."""
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
         colors = [(1.0, 1.0, 1.0), color]
-        
+
         draw_funcs = [self.__class__.fill_polyline, self.__class__.draw_polyline]
         for i in range(0, 2):
             color = colors[i]
             draw_func = draw_funcs[i]
             draw_func(self, [(x, y), (x - height / 2.0, y + height / 2.0), (x, y + height), (x, y)], \
                       color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_resume_triangle(self, x, y, height, event):
         self.add_sel_region(SelectableRegion(x - height / 2.0, y, height / 2.0, height, event))
-    
+
     def clear_selectable_regions(self):
         self.selectable_regions = {}
-            
+
     #def clear_selectable_regions(self, real_x, real_y, width, height):
     #    x, y = self.surface.get_virt_coor(real_x, real_y)
     #    for event in self.selectable_regions.keys():
     #        if self.selectable_regions[event].intersects(x, y, width, height):
     #            del self.selectable_regions[event]
-        
+
     def add_sel_region(self, region):
         region.set_scale(self.scale)
         self.selectable_regions[region.get_event()] = region
-    
+
     def get_sel_region(self, event):
         return self.selectable_regions[event]
-    
+
     def has_sel_region(self, event):
         return event in self.selectable_regions
-                
+
     def get_selected_regions(self, real_x, real_y, width, height):
         x, y = self.surface.get_virt_coor(real_x, real_y)
-    
+
         selected = {}
         for event in self.selectable_regions:
             region = self.selectable_regions[event]
             if region.intersects(x, y, width, height):
                 selected[event] = region
-        
+
         return selected
-        
+
     def whiteout(self):
         """Overwrites the surface completely white, but technically doesn't delete anything"""
         # Make sure we don't scale here (we want to literally white out just this region)
-        
+
         x, y = self.surface.get_virt_coor_unscaled(0, 0)
         width, height = self.unscaled(self.surface.width, self.surface.height)
-        
+
         self.fill_rect(x, y, width, 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
         on the y-axis. Note that there are conceptually infinitely
         many patterns because the patterns repeat -- that is, we just mod out by the size of the pattern
         list when indexing."""
         return self.item_clist[n % len(self.item_clist)]
-    
+
     def get_bar_pattern(self, n):
         """Gets the nth pattern in the bar pattern list, which is a list of surfaces that are used to
         fill in the bars. Note that there are conceptually infinitely
@@ -574,38 +574,38 @@ class CairoCanvas(Canvas):
     """This is a basic class that stores and draws on a Cairo surface,
     using various primitives related to drawing a real-time graph (up-arrows,
     down-arrows, bars, ...).
-    
+
     This is the lowest-level non-abstract representation
     (aside perhaps from the Cairo surface itself) of a real-time graph.
     It allows the user to draw primitives at certain locations, but for
     the most part does not know anything about real-time scheduling,
     just how to draw the basic parts that make up a schedule graph.
     For that, see Graph or its descendants."""
-    
+
     #def __init__(self, fname, width, height, item_clist, bar_plist, surface):
     #    """Creates a new Canvas of dimensions (width, height). The
     #    parameters ``item_plist'' and ``bar_plist'' each specify a list
     #    of patterns to choose from when drawing the items on the y-axis
     #    or filling in bars, respectively."""
-        
+
     #    super(CairoCanvas, self).__init__(fname, width, height, item_clist, bar_plist, surface)
-    
+
     #def clear(self):
     #    self.surface = self.SurfaceType(self.width, self.height, self.fname)
     #    self.whiteout()
-        
+
     def get_surface(self):
         """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, clip_side=None, do_snap=True):
         EXTRA_FACTOR = 2.0
-        
+
         x, y, width, height = self.scaled(x, y, width, height)
         x, y = self.surface.get_real_coor(x, y)
         max_width = self.surface.width + EXTRA_FACTOR * thickness
         max_height = self.surface.height + EXTRA_FACTOR * thickness
-        
+
         # if dimensions are really large this can cause Cairo problems --
         # so clip it to the size of the surface, which is the only part we see anyway
         if x < 0:
@@ -618,11 +618,11 @@ class CairoCanvas(Canvas):
             width = max_width
         if height > max_height:
             height = max_height
-            
+
         if do_snap:
             x = snap(x)
             y = snap(y)
-            
+
         if clip_side == AlignMode.LEFT:
             self.surface.ctx.move_to(x, y)
             self.surface.ctx.line_to(x + width, y)
@@ -636,23 +636,23 @@ class CairoCanvas(Canvas):
         else:
             # don't clip one edge of the rectangle -- just draw a Cairo rectangle
             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, clip_side=None, do_snap=True):
         self._rect_common(x, y, width, height, color, thickness, clip_side, do_snap)
         self.surface.ctx.stroke()
-    
+
     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, 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)
-        
+
         if do_snap:
             linear = cairo.LinearGradient(snap(x), snap(y), \
                                       snap(x + width), snap(y + height))
@@ -667,7 +667,7 @@ class CairoCanvas(Canvas):
         else:
             self.surface.ctx.rectangle(x, y, width, height)
         self.surface.ctx.fill()
-            
+
     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])
@@ -677,36 +677,36 @@ class CairoCanvas(Canvas):
         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, do_snap=True):
         scaled_coor_list = [self.scaled(coor[0], coor[1]) for coor in coor_list]
         real_coor_list = [self.surface.get_real_coor(coor[0], coor[1]) for coor in scaled_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.scale)    
+
+        self.surface.ctx.set_line_width(thickness * self.scale)
         self.surface.ctx.set_source_rgb(color[0], color[1], color[2])
-        
+
     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, 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, do_snap=True):
         """Helper function for drawing a label with some alignment. Instead of taking in an alignment,
@@ -714,30 +714,30 @@ class CairoCanvas(Canvas):
         the x and y parameters. Only should be used internally."""
         x, y = self.scaled(x, y)
         x, y = self.surface.get_real_coor(x, y)
-        
+
         self.surface.ctx.set_source_rgb(0.0, 0.0, 0.0)
-            
+
         self.surface.ctx.select_font_face(fopts.name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
         self.surface.ctx.set_font_size(fopts.size * self.scale)
-        
+
         fe = self.surface.ctx.font_extents()
         f_ascent, f_descent, f_height = fe[:3]
-        
+
         te = self.surface.ctx.text_extents(text)
         x_bearing, y_bearing, width, height = te[:4]
-        
+
         actual_x = x - x_bearing * x_bearing_factor - width * width_factor
         actual_y = y - f_descent * f_descent_factor + f_height * f_height_factor
-        
+
         self.surface.ctx.set_source_rgb(fopts.color[0], fopts.color[1], fopts.color[2])
-        
+
         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, 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
@@ -747,21 +747,21 @@ class CairoCanvas(Canvas):
         if halign not in halign_factors:
             raise ValueError('Invalid alignment value')
         x_bearing_factor, width_factor = halign_factors[halign]
-        
+
         valign_factors = {AlignMode.BOTTOM : (0.0, 0.0), AlignMode.CENTER : (1.0, 0.5), AlignMode.TOP : (1.0, 1.0)}
         if valign not in valign_factors:
             raise ValueError('Invalid alignment value')
         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, do_snap)    
-    
+                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, 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)
-        
+
         self.surface.ctx.set_source_rgb(0.0, 0.0, 0.0)
         self.surface.ctx.select_font_face(textfopts.name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
         self.surface.ctx.set_font_size(textfopts.size)
@@ -781,7 +781,7 @@ class CairoCanvas(Canvas):
             ytmp = y
             ytmp = y + f_height / 4.0
             self.draw_label(subscript, xtmp, ytmp, sscriptfopts, halign, valign, do_snap)
-        
+
 # represents a selectable region of the graph
 class SelectableRegion(object):
     def __init__(self, x, y, width, height, event):
@@ -791,19 +791,19 @@ class SelectableRegion(object):
         self.height = height
         self.event = event
         self.scale = 1.0
-    
+
     def get_dimensions(self):
         return (self.x, self.y, self.width, self.height)
-        
+
     def get_event(self):
         return self.event
-    
+
     def set_scale(self, scale):
         self.scale = scale
-        
+
     def intersects(self, x, y, width, height):
         return x <= (self.x + self.width) * self.scale \
            and x + width >= self.x * self.scale \
            and y <= (self.y + self.height) * self.scale \
            and y + height >= self.y * self.scale
-        
+
diff --git a/unit_trace/viz/convert.py b/unit_trace/viz/convert.py
index a7aff8b..d19bc73 100644
--- a/unit_trace/viz/convert.py
+++ b/unit_trace/viz/convert.py
@@ -24,13 +24,13 @@ def _get_job_from_record(sched, record):
         sched.get_tasks()[tname].add_job(Job(job_no, []))
     job = sched.get_tasks()[tname].get_jobs()[job_no]
     return job
-    
+
 def convert_trace_to_schedule(stream):
     """The main function of interest in this module. Coverts a stream of records
     to a Schedule object."""
     def noop():
         pass
-            
+
     num_cpus, stream = _find_num_cpus(stream)
     sched = Schedule('sched', num_cpus)
     for record in stream:
@@ -41,10 +41,10 @@ def convert_trace_to_schedule(stream):
         if record.record_type == 'event':
             job = _get_job_from_record(sched, record)
             cpu = record.cpu
-        
+
             if not hasattr(record, 'deadline'):
                 record.deadline = None
-                
+
             actions = {
                 'name' : (noop),
                 'params' : (noop),
@@ -64,27 +64,27 @@ def convert_trace_to_schedule(stream):
                 job.add_event(ResumeEvent(record.when, cpu))),
                 'sys_release' : (noop)
             }
-        
+
             actions[record.type_name]()
-    
+
         elif record.record_type == 'error':
             job = _get_job_from_record(sched, record.job)
-            
+
             actions = {
                 'inversion_start' : (lambda :
                 job.add_event(InversionStartEvent(record.job.inversion_start))),
                 'inversion_end' : (lambda :
                 job.add_event(InversionEndEvent(record.job.inversion_end)))
             }
-        
+
             actions[record.type_name]()
-    
+
     return sched
-    
+
 def _pid_to_task_name(pid):
     """Converts a PID to an appropriate name for a task."""
     return str(pid)
-          
+
 def _find_num_cpus(stream):
     """Determines the number of CPUs used by scanning the binary format."""
     max = 0
@@ -94,7 +94,7 @@ def _find_num_cpus(stream):
         if record.record_type == 'event':
             if record.cpu > max:
                 max = record.cpu
-    
+
     def recycle(l):
         for record in l:
             yield record
diff --git a/unit_trace/viz/format.py b/unit_trace/viz/format.py
index 33e0b03..c544e26 100644
--- a/unit_trace/viz/format.py
+++ b/unit_trace/viz/format.py
@@ -13,41 +13,41 @@ class AlignMode(object):
     LEFT = 0
     CENTER = 1
     RIGHT = 2
-    
+
     BOTTOM = 3
     TOP = 4
-        
+
 class GraphFormat(object):
     """Container class for a bunch of optional and non-optional attributes to configure the appearance of the graph
     (because it would be annoying to just have these all as raw arguments to the Graph constructor, and many people
     probably don't care about most of them anyway)."""
-    
+
     GRID_COLOR = (0.7, 0.7, 0.7)
     HIGHLIGHT_COLOR = (0.85, 0.0, 0.0)
     BORDER_COLOR = (0.0, 0.0, 0.0)
     LITE_BORDER_COLOR = (0.4, 0.4, 0.4)
-    
+
     BORDER_THICKNESS = 1
     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
     MAJ_TICK_SIZE = 20
     MIN_TICK_SIZE = 12
-    
+
     BIG_ARROWHEAD_FACTOR = 0.2
     SMALL_ARROWHEAD_FACTOR = 0.3
     TEE_FACTOR = 0.3
-    
+
     DEF_FOPTS_LABEL = FontOptions("Times", 16, (0.0, 0.0, 0.0))
     DEF_FOPTS_LABEL_SSCRIPT = FontOptions("Times", 8, (0.0, 0.0, 0.0))
     DEF_FOPTS_MAJ = FontOptions("Times", 14, (0.1, 0.1, 0.1))
-    DEF_FOPTS_MIN = FontOptions("Times", 9, (0.1, 0.1, 0.1)) 
+    DEF_FOPTS_MIN = FontOptions("Times", 9, (0.1, 0.1, 0.1))
     DEF_FOPTS_ITEM = FontOptions("Times", 20, (0.0, 0.5, 0.1))
     DEF_FOPTS_BAR = FontOptions("Times", 14, (0.0, 0.0, 0.0))
     DEF_FOPTS_BAR_SSCRIPT = FontOptions("Times", 7, (0.0, 0.0, 0.0))
@@ -55,31 +55,31 @@ class GraphFormat(object):
     DEF_FOPTS_MINI_BAR_SSCRIPT = FontOptions("Times", 7, (0.0, 0.0, 0.0))
     DEF_FOPTS_ARROW = FontOptions("Times", 12, (0.0, 0.0, 0.0))
     DEF_FOPTS_ARROW_SSCRIPT = FontOptions("Times", 7, (0.0, 0.0, 0.0))
-    
+
     LEFT_SIDE_PAD = 30
     WIDTH_PAD = 50
     HEIGHT_PAD = 150
     Y_ITEM_PAD_FACTOR = 0.5
-    
+
     DEF_TIME_PER_MAJ = 10
     DEF_MAJ_SEP = 200
     DEF_MIN_PER_MAJ = 5
     DEF_Y_ITEM_SIZE = 50
-    
+
     AXIS_LABEL_VERT_OFS = 30
     BAR_SIZE_FACTOR = 0.4
     MINI_BAR_SIZE_FACTOR = 0.2
     BAR_MINI_BAR_GAP_FACTOR = 0.1
-                
+
     BAR_LABEL_OFS = 2
     MINI_BAR_LABEL_OFS = 1
     ARROW_LABEL_OFS = 2
-    
+
     BLOCK_TRIANGLE_FACTOR = 0.7
     BIG_ARROW_FACTOR = 1.6
     SMALL_ARROW_FACTOR = 0.6
     COMPLETION_MARKER_FACTOR = 1.6
-    
+
     def __init__(self, time_per_maj=DEF_TIME_PER_MAJ, maj_sep=DEF_MAJ_SEP, \
     min_per_maj=DEF_MIN_PER_MAJ, y_item_size=DEF_Y_ITEM_SIZE, bar_fopts=DEF_FOPTS_BAR, \
     item_fopts=DEF_FOPTS_ITEM, show_min=False, majfopts=DEF_FOPTS_MAJ, \
diff --git a/unit_trace/viz/graph.py b/unit_trace/viz/graph.py
index 6982e7c..a10d9bd 100644
--- a/unit_trace/viz/graph.py
+++ b/unit_trace/viz/graph.py
@@ -13,7 +13,7 @@ class Graph(object):
                      Pattern([(0.75, 0.75, 0.75)])]
     DEF_ITEM_CLIST = [(0.3, 0.0, 0.0), (0.0, 0.3, 0.0), (0.0, 0.0, 0.3), (0.3, 0.3, 0.0), (0.0, 0.3, 0.3),
                       (0.3, 0.0, 0.3)]
-    
+
     def __init__(self, CanvasType, surface, start_time, end_time, y_item_list, attrs=GraphFormat(),
                  item_clist=DEF_ITEM_CLIST, bar_plist=DEF_BAR_PLIST):
         # deal with possibly blank schedules
@@ -21,16 +21,16 @@ class Graph(object):
             start_time = 0
         if end_time is None:
             end_time = 0
-         
+
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
+
         self.attrs = attrs
         self.start_time = start_time
         self.end_time = end_time
         self.y_item_list = y_item_list
         self.num_maj = int(math.ceil((self.end_time - self.start_time) * 1.0 / self.attrs.time_per_maj)) + 1
-    
+
         width = self.num_maj * self.attrs.maj_sep + GraphFormat.X_AXIS_MEASURE_OFS + GraphFormat.WIDTH_PAD
         height = (len(self.y_item_list) + 1) * self.attrs.y_item_size + GraphFormat.HEIGHT_PAD
 
@@ -40,7 +40,7 @@ class Graph(object):
         extra_width = 0.0
         dummy_surface = surface.__class__()
         dummy_surface.renew(10, 10)
-        
+
         dummy_surface.ctx.select_font_face(self.attrs.item_fopts.name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
         dummy_surface.ctx.set_font_size(self.attrs.item_fopts.size)
         for item in self.y_item_list:
@@ -49,49 +49,49 @@ class Graph(object):
             cur_width = te[2]
             if cur_width > extra_width:
                 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
         self.height = height
-        
+
         #if surface.ctx is None:
         #    surface.renew(width, height)
-        
+
         self.canvas = CanvasType(width, height, item_clist, bar_plist, surface)
-    
+
     def get_selected_regions(self, real_x, real_y, width, height):
         return self.canvas.get_selected_regions(real_x, real_y, width, height)
-                
+
     def get_width(self):
         return self.width
-        
+
     def get_height(self):
         return self.height
-    
+
     def get_origin(self):
         return self.origin
-        
+
     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 has_sel_region(self, event):
         return self.canvas.has_sel_region(event)
-            
+
     def update_view(self, x, y, width, height, scale, ctx):
         """Proxy into the surface's pan."""
         self.canvas.surface.pan(x, y, width, height)
         self.canvas.set_scale(scale)
         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
@@ -101,93 +101,93 @@ class Graph(object):
             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):
+
+    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
-    
-    def _get_item_ypos(self, item_no):
+
+    def get_item_ypos(self, item_no):
         """get y so that y is where the top of a bar would be in item #n's area"""
-        return self.origin[1] - self._get_y_axis_height() + self.attrs.y_item_size * (item_no + 0.5 - GraphFormat.BAR_SIZE_FACTOR / 2.0)     
-    
+        return self.origin[1] - self._get_y_axis_height() + self.attrs.y_item_size * (item_no + 0.5 - GraphFormat.BAR_SIZE_FACTOR / 2.0)
+
     def _get_bar_width(self, start_time, end_time):
         return 1.0 * (end_time - start_time) / self.attrs.time_per_maj * self.attrs.maj_sep
-    
+
     def _get_bar_height(self):
         return self.attrs.y_item_size * GraphFormat.BAR_SIZE_FACTOR
-    
+
     def _get_mini_bar_height(self):
         return self.attrs.y_item_size * GraphFormat.MINI_BAR_SIZE_FACTOR
-        
+
     def _get_mini_bar_ofs(self):
         return self.attrs.y_item_size * (GraphFormat.MINI_BAR_SIZE_FACTOR + GraphFormat.BAR_MINI_BAR_GAP_FACTOR)
-        
+
     def _get_y_axis_height(self):
         return (len(self.y_item_list) + 1) * self.attrs.y_item_size
-    
+
     def _get_bottom_tick(self, time):
         return int(math.floor((time - self.start_time) / self.attrs.time_per_maj))
-    
+
     def _get_top_tick(self, time):
         return int(math.ceil((time - self.start_time) / self.attrs.time_per_maj))
-        
+
     def get_surface(self):
         """Gets the underlying surface."""
         return self.canvas.get_surface()
-    
+
     def xcoor_to_time(self, x):
         #x = self.origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + (time - self.start) / self.attrs.time_per_maj * self.attrs.maj_sep
         return (x - self.origin[0] - GraphFormat.X_AXIS_MEASURE_OFS) / self.attrs.maj_sep \
                 * self.attrs.time_per_maj + self.start_time
-    
+
     def ycoor_to_item_no(self, y):
-        return int((y - self.origin[1] + self._get_y_axis_height()) // self.attrs.y_item_size) 
-    
+        return int((y - self.origin[1] + self._get_y_axis_height()) // self.attrs.y_item_size)
+
     def get_offset_params(self, real_x, real_y, width, height):
         x_start, y_start = self.canvas.surface.get_virt_coor_unscaled(real_x, real_y)
         x_end, y_end = self.canvas.surface.get_virt_coor_unscaled(real_x + width, real_y + height)
-        
+
         start_time = self.xcoor_to_time(x_start)
         end_time = self.xcoor_to_time(x_end)
-        
+
         start_item = self.ycoor_to_item_no(y_start)
         end_item = 1 + self.ycoor_to_item_no(y_end)
-        
+
         return (start_time, end_time, start_item, end_item)
-    
+
     def draw_skeleton(self, start_time, end_time, start_item, end_item):
         self.draw_grid_at_time(start_time, end_time, start_item, end_item)
         self.draw_x_axis_with_labels_at_time(start_time, end_time)
         self.draw_y_axis_with_labels()
-            
+
     def render_surface(self, sched, regions, selectable=False):
         raise NotImplementedError
-    
+
     def render_all(self, schedule):
         raise NotImplementedError
-    
+
     def get_events_to_render(self, sched, regions, selectable=False):
         raise NotImplementedError
-        
+
     def render_surface(self, sched, regions, selectable=False):
         if not selectable:
             self.canvas.whiteout()
         else:
             self.canvas.clear_selectable_regions()
         self.render_events(self.get_events_to_render(sched, regions, selectable), selectable)
-        
+
     def render_events(self, events, selectable=False):
         for layer in Canvas.LAYERS:
             prev_events = {}
             if layer in events:
                 for event in events[layer]:
                     event.render(self, layer, prev_events, selectable)
-                                        
+
     def draw_axes(self, x_axis_label, y_axis_label):
         """Draws and labels the axes according to the parameters that we were initialized
-        with."""    
+        with."""
         self.draw_grid_at_time(self.start_time, self.end_time, 0, len(self.attrs.y_item_list) - 1)
-        
+
         self.canvas.draw_x_axis(self.origin[0], self.origin[1], self.num_maj, self.attrs.maj_sep, self.attrs.min_per_maj)
         self.canvas.draw_y_axis(self.origin[0], self.origin[1], self._get_y_axis_height())
         self.canvas.draw_x_axis_labels(self.origin[0], self.origin[1], 0, self.num_maj - 1,\
@@ -195,425 +195,425 @@ class Graph(object):
                                 self.attrs.time_per_maj, self.attrs.show_min, self.attrs.majfopts, self.attrs.minfopts)
         self.canvas.draw_y_axis_labels(self.origin[0], self.origin[1], self._get_y_axis_height(), self.y_item_list, \
                                        self.attrs.y_item_size, self.attrs.item_fopts)
-    
+
     def draw_grid_at_time(self, start_time, end_time, start_item, end_item):
         """Draws the grid, but only in a certain time and item range."""
         start_tick = max(0, self._get_bottom_tick(start_time))
         end_tick = min(self.num_maj - 1, self._get_top_tick(end_time))
-        
+
         start_item = max(0, start_item)
         end_item = min(len(self.y_item_list), end_item)
-        
+
         self.canvas.draw_grid(self.origin[0], self.origin[1], self._get_y_axis_height(),
                               start_tick, end_tick, start_item, end_item, self.attrs.maj_sep, self.attrs.y_item_size, \
                               self.attrs.min_per_maj, True)
-    
+
     def draw_x_axis_with_labels_at_time(self, start_time, end_time):
         start_tick = max(0, self._get_bottom_tick(start_time))
         end_tick = min(self.num_maj - 1, self._get_top_tick(end_time))
-                                      
+
         self.canvas.draw_x_axis(self.origin[0], self.origin[1], start_tick, end_tick, \
                                 self.attrs.maj_sep, self.attrs.min_per_maj)
         self.canvas.draw_x_axis_labels(self.origin[0], self.origin[1], start_tick, \
                                 end_tick, self.attrs.maj_sep, self.attrs.min_per_maj,
                                 self.start_time + start_tick * self.attrs.time_per_maj,
                                 self.attrs.time_per_maj, False)
-                                
+
     def draw_y_axis_with_labels(self):
         self.canvas.draw_y_axis(self.origin[0], self.origin[1], self._get_y_axis_height())
         self.canvas.draw_y_axis_labels(self.origin[0], self.origin[1], self._get_y_axis_height(), \
                                        self.y_item_list, self.attrs.y_item_size)
-            
+
     def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         """Draws a suspension symbol for a dcertain task at an instant in time."""
         raise NotImplementedError
-    
+
     def add_sel_suspend_triangle_at_time(self, time, task_no, cpu_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-    
+
     def draw_resume_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         """Draws a resumption symbol for a certain task at an instant in time."""
         raise NotImplementedError
-    
+
     def add_sel_resume_triangle_at_time(self, time, task_no, cpu_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-            
+
     def draw_completion_marker_at_time(self, time, task_no, cpu_no, selected=False):
         """Draws a completion marker for a certain task at an instant in time."""
         raise NotImplementedError
-    
+
     def add_sel_completion_marker_at_time(self, time, task_no, cpu_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-            
+
     def draw_release_arrow_at_time(self, time, task_no, job_no, selected=False):
         """Draws a release arrow at a certain time for some task and job"""
         raise NotImplementedError
-    
+
     def add_sel_release_arrow_at_time(self, time, task_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-            
+
     def draw_deadline_arrow_at_time(self, time, task_no, job_no, selected=False):
         """Draws a deadline arrow at a certain time for some task and job"""
         raise NotImplementedError
-    
+
     def add_sel_deadline_arrow_at_time(self, time, task_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-        
+
     def draw_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None):
         """Draws a bar over a certain time period for some task, optionally labelling it."""
         raise NotImplementedError
-        
+
     def add_sel_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-    
+
     def draw_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, clip_side=None, job_no=None):
         """Draws a mini bar over a certain time period for some task, optionally labelling it."""
         raise NotImplementedError
-        
+
     def add_sel_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-            
+
 class TaskGraph(Graph):
     def get_events_to_render(self, sched, regions, selectable=False):
         slots = {}
-        
-        self.min_time, self.max_time, self.min_item, self.max_item = None, None, None, None  
+
+        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)
-            
+
             sched.get_time_slot_array().get_slots(slots,
                         start_time, end_time, start_item, end_item,
                         schedule.TimeSlotArray.TASK_LIST)
 
-        
+
         if not selectable:
             self.draw_skeleton(self.min_time, self.max_time,
                                self.min_item, self.max_item)
-        
+
         events_to_render = {}
         for layer in Canvas.LAYERS:
             events_to_render[layer] = {}
-        
+
         for event in sched.get_time_slot_array().get_events(slots,
                 schedule.TimeSlotArray.TASK_LIST,
                 schedule.EVENT_LIST):
-            events_to_render[event.get_layer()][event] = None    
-        
+            events_to_render[event.get_layer()][event] = None
+
         return events_to_render
-        
+
     def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
         self.canvas.draw_suspend_triangle(x, y, height, selected)
-    
+
     def add_sel_suspend_triangle_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.add_sel_suspend_triangle(x, y, height, event)
-        
+
     def draw_resume_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.draw_resume_triangle(x, y, height, selected)
-    
+
     def add_sel_resume_triangle_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.add_sel_resume_triangle(x, y, height, event)
-        
+
     def draw_completion_marker_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() - height
+
         self.canvas.draw_completion_marker(x, y, height, selected)
-    
+
     def add_sel_completion_marker_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() - height
+
         self.canvas.add_sel_completion_marker(x, y, height, event)
-            
+
     def draw_release_arrow_at_time(self, time, task_no, job_no=None, selected=False):
         height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() - height
+
         self.canvas.draw_release_arrow_big(x, y, height, selected)
-    
+
     def add_sel_release_arrow_at_time(self, time, task_no, event):
         height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() - height
+
         self.canvas.add_sel_release_arrow_big(x, y, height, event)
-        
+
     def draw_deadline_arrow_at_time(self, time, task_no, job_no=None, selected=False):
         height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no)
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no)
+
         self.canvas.draw_deadline_arrow_big(x, y, height, selected)
-    
+
     def add_sel_deadline_arrow_at_time(self, time, task_no, event):
         height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no)
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no)
+
         self.canvas.add_sel_deadline_arrow_big(x, y, height, event)
-        
+
     def draw_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(task_no)
+
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(task_no)
         width = self._get_bar_width(start_time, end_time)
         height = self._get_bar_height()
-        
+
         self.canvas.draw_bar(x, y, width, height, cpu_no, clip_side, selected)
-        
+
         # if a job number is specified, we want to draw a superscript and subscript for the task and job number, respectively
         if job_no is not None:
             x += GraphFormat.BAR_LABEL_OFS
             y += self.attrs.y_item_size * GraphFormat.BAR_SIZE_FACTOR / 2.0
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                 GraphFormat.DEF_FOPTS_BAR, GraphFormat.DEF_FOPTS_BAR_SSCRIPT, AlignMode.LEFT, AlignMode.CENTER)
-    
+
     def add_sel_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(task_no)
+
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(task_no)
         width = self._get_bar_width(start_time, end_time)
         height = self._get_bar_height()
-        
+
         self.canvas.add_sel_bar(x, y, width, height, event)
-    
+
     def draw_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(task_no) - self._get_mini_bar_ofs()
+
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(task_no) - self._get_mini_bar_ofs()
         width = self._get_bar_width(start_time, end_time)
         height = self._get_mini_bar_height()
-        
+
         self.canvas.draw_mini_bar(x, y, width, height, Canvas.NULL_PATTERN, clip_side, selected)
-        
+
         if job_no is not None:
             x += GraphFormat.MINI_BAR_LABEL_OFS
             y += self.attrs.y_item_size * GraphFormat.MINI_BAR_SIZE_FACTOR / 2.0
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                 GraphFormat.DEF_FOPTS_MINI_BAR, GraphFormat.DEF_FOPTS_MINI_BAR_SSCRIPT, AlignMode.LEFT, AlignMode.CENTER)
-                
+
     def add_sel_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(task_no) - self._get_mini_bar_ofs()
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(task_no) - self._get_mini_bar_ofs()
         width = self._get_bar_width(start_time, end_time)
         height = self._get_mini_bar_height()
-        
+
         self.canvas.add_sel_mini_bar(x, y, width, height, event)
-        
+
 class CpuGraph(Graph):
     def get_events_to_render(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]
-        
+
         if not regions:
             return {}
-            
+
         top_slots = {}
         bottom_slots = {}
-        
+
         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)
-            
+
             sched.get_time_slot_array().get_slots(top_slots,
                         start_time, end_time, start_item, end_item,
                         schedule.TimeSlotArray.CPU_LIST)
-        
+
             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
                 sched.get_time_slot_array().get_slots(bottom_slots,
                         start_time, end_time, 0, sched.get_num_cpus(),
                         schedule.TimeSlotArray.CPU_LIST)
-        
+
         if not selectable:
             self.draw_skeleton(self.min_time, self.max_time,
                                self.min_item, self.max_item)
-        
+
         events_to_render = {}
         for layer in Canvas.LAYERS:
             events_to_render[layer] = {}
-        
+
         for event in sched.get_time_slot_array().get_events(top_slots,
                 schedule.TimeSlotArray.CPU_LIST,
                 TOP_EVENTS):
-            events_to_render[event.get_layer()][event] = None  
+            events_to_render[event.get_layer()][event] = None
         for event in sched.get_time_slot_array().get_events(bottom_slots,
                 schedule.TimeSlotArray.CPU_LIST,
                 BOTTOM_EVENTS):
-            events_to_render[event.get_layer()][event] = None  
-        
+            events_to_render[event.get_layer()][event] = None
+
         return events_to_render
-                
+
     def render(self, schedule, start_time=None, end_time=None):
         if end_time < start_time:
             raise ValueError('start must be less than end')
-            
+
         if start_time is None:
             start_time = self.start
         if end_time is None:
             end_time = self.end
         start_slot = self.get_time_slot(start_time)
         end_slot = min(len(self.time_slots), self.get_time_slot(end_time) + 1)
-        
+
         for layer in Canvas.LAYERS:
             prev_events = {}
             for i in range(start_slot, end_slot):
                 for event in self.time_slots[i]:
                     event.render(graph, layer, prev_events)
-                    
+
     def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
         self.canvas.draw_suspend_triangle(x, y, height, selected)
-    
+
     def add_sel_suspend_triangle_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.add_sel_suspend_triangle(x, y, height, event)
-        
+
     def draw_resume_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.draw_resume_triangle(x, y, height, selected)
-    
+
     def add_sel_resume_triangle_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.add_sel_resume_triangle(x, y, height, event)
-        
+
     def draw_completion_marker_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() - height
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() - height
+
         self.canvas.draw_completion_marker(x, y, height, selected)
-    
+
     def add_sel_completion_marker_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() - height
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() - height
+
         self.canvas.add_sel_completion_marker(x, y, height, event)
-            
+
     def draw_release_arrow_at_time(self, time, task_no, job_no=None, selected=False):
         if job_no is None and task_no is not None:
             raise ValueError("Must specify a job number along with the task number")
-            
+
         height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
+
+        x = self.get_time_xpos(time)
         y = self.origin[1] - height
-        
+
         self.canvas.draw_release_arrow_small(x, y, height, selected)
-    
+
         if task_no is not None:
             y -= GraphFormat.ARROW_LABEL_OFS
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                                           GraphFormat.DEF_FOPTS_ARROW, GraphFormat.DEF_FOPTS_ARROW_SSCRIPT, \
                                           AlignMode.CENTER, AlignMode.BOTTOM)
-    
+
     def add_sel_release_arrow_at_time(self, time, task_no, event):
         height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
+
+        x = self.get_time_xpos(time)
         y = self.origin[1] - height
-        
+
         self.canvas.add_sel_release_arrow_small(x, y, height, event)
-            
+
     def draw_deadline_arrow_at_time(self, time, task_no, job_no=None, selected=False):
         if job_no is None and task_no is not None:
             raise ValueError("Must specify a job number along with the task number")
-            
+
         height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
+
+        x = self.get_time_xpos(time)
         y = self.origin[1] - height
-        
+
         self.canvas.draw_deadline_arrow_small(x, y, height, selected)
-    
+
         if task_no is not None:
             y -= GraphFormat.ARROW_LABEL_OFS
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                                           GraphFormat.DEF_FOPTS_ARROW, GraphFormat.DEF_FOPTS_ARROW_SSCRIPT, \
                                           AlignMode.CENTER, AlignMode.BOTTOM)
-    
+
     def add_sel_deadline_arrow_at_time(self, time, task_no, event):
         height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
+
+        x = self.get_time_xpos(time)
         y = self.origin[1] - height
-        
+
         self.canvas.add_sel_deadline_arrow_small(x, y, height, event)
-        
+
     def draw_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(cpu_no)
+
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(cpu_no)
         width = self._get_bar_width(start_time, end_time)
         height = self._get_bar_height()
-        
+
         self.canvas.draw_bar(x, y, width, height, task_no, clip_side, selected)
-        
+
         # if a job number is specified, we want to draw a superscript and subscript for the task and job number, respectively
         if job_no is not None:
             x += GraphFormat.BAR_LABEL_OFS
@@ -621,37 +621,37 @@ class CpuGraph(Graph):
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                                                  GraphFormat.DEF_FOPTS_BAR, GraphFormat.DEF_FOPTS_BAR_SSCRIPT, \
                                                  AlignMode.LEFT, AlignMode.CENTER)
-    
+
     def add_sel_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(cpu_no)
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(cpu_no)
         width = self._get_bar_width(start_time, end_time)
         height = self._get_bar_height()
-        
+
         self.canvas.add_sel_bar(x, y, width, height, event)
-    
+
     def draw_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(len(self.y_item_list))
+
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(len(self.y_item_list))
         width = self._get_bar_width(start_time, end_time)
         height = self._get_mini_bar_height()
-        
+
         self.canvas.draw_mini_bar(x, y, width, height, task_no, clip_side, selected)
-        
+
         if job_no is not None:
             x += GraphFormat.MINI_BAR_LABEL_OFS
             y += self.attrs.y_item_size * GraphFormat.MINI_BAR_SIZE_FACTOR / 2.0
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                 GraphFormat.DEF_FOPTS_MINI_BAR, GraphFormat.DEF_FOPTS_MINI_BAR_SSCRIPT, AlignMode.LEFT, AlignMode.CENTER)
-                
+
     def add_sel_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(len(self.y_item_list))
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(len(self.y_item_list))
         width = self._get_bar_width(start_time, end_time)
         height = self._get_mini_bar_height()
-        
+
         self.canvas.add_sel_mini_bar(x, y, width, height, event)
 
diff --git a/unit_trace/viz/renderer.py b/unit_trace/viz/renderer.py
index 4b231c4..056e1a5 100644
--- a/unit_trace/viz/renderer.py
+++ b/unit_trace/viz/renderer.py
@@ -4,17 +4,17 @@ from graph import *
 
 """The renderer, a glue object which converts a schedule to its representation
 on a graph."""
-        
+
 class Renderer(object):
     def __init__(self, schedule):
         self.schedule = schedule
-    
+
     def prepare_task_graph(self, SurfaceType=ImageSurface, attrs=GraphFormat()):
         """Outputs the fully-rendered graph (y-axis = tasks) to a Cairo ImageSurface"""
         item_list = self.get_task_item_list()
         start, end = self.schedule.get_time_bounds()
         self.graph = TaskGraph(CairoCanvas, SurfaceType(), start, end, item_list, attrs)
-    
+
     def prepare_cpu_graph(self, SurfaceType=ImageSurface, attrs=GraphFormat()):
         item_list = ['CPU %d' % i for i in range(0, self.schedule.get_num_cpus())]
         start, end = self.schedule.get_time_bounds()
@@ -25,16 +25,16 @@ class Renderer(object):
         and drawing it piece by piece"""
         #graph.draw_axes('Time', '')
         self.schedule.render(self.graph)
-    
+
     def write_out(self, fname):
         self.graph.surface.write_out(fname)
-        
+
     def get_graph(self):
         return self.graph
-    
+
     def get_schedule(self):
         return self.schedule
-        
+
     def get_task_item_list(self):
         return [task.get_name() for task in self.schedule.get_task_list()]
-    
+
diff --git a/unit_trace/viz/schedule.py b/unit_trace/viz/schedule.py
index 81269fa..a44ce8d 100644
--- a/unit_trace/viz/schedule.py
+++ b/unit_trace/viz/schedule.py
@@ -18,19 +18,19 @@ class TimeSlotArray(object):
     the (approximate) time at which they occur. Events that occur at approximately the same
     time are assigned the same ``slot'', and each slot organizes its events by task number
     as well as by CPU."""
-    
+
     TASK_LIST = 0
     CPU_LIST = 1
-    
+
     def __init__(self, time_per_maj=None, num_tasks=0, num_cpus=0):
         if time_per_maj is None:
             self.array = None
             return
-            
+
         self.time_per_maj = time_per_maj
         self.list_sizes = { TimeSlotArray.TASK_LIST : num_tasks, TimeSlotArray.CPU_LIST : num_cpus }
         self.array = {}
-        
+
         for type in self.list_sizes:
             num = self.list_sizes[type]
             self.array[type] = []
@@ -40,26 +40,26 @@ class TimeSlotArray(object):
                 # by task).
                 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.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._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)
-        
+
         if event.__class__ in SPAN_END_EVENTS:
             self.fill_span_event_from_end(event)
-        
+
     def fill_span_event_from_end(self, event):
         start_slot = None
         if event.corresp_start_event is None:
@@ -67,18 +67,18 @@ class TimeSlotArray(object):
         else:
             start_slot = self.get_time_slot(event.corresp_start_event.get_time())
         end_slot = self.get_time_slot(event.get_time())
-        
+
         for slot in range(start_slot + 1, end_slot):
             task_no = event.get_job().get_task().get_task_no()
             cpu = event.get_cpu()
-            
+
             dummy = SPAN_END_EVENTS[event.__class__](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)
-            
+
     def fill_span_event_from_start(self, event):
         end_slot = None
         if event.corresp_end_event is None:
@@ -86,18 +86,18 @@ class TimeSlotArray(object):
         else:
             end_slot = self.get_time_slot(event.corresp_end_event.get_time())
         start_slot = self.get_time_slot(event.get_time())
-        
+
         for slot in range(start_slot + 1, end_slot):
             task_no = event.get_job().get_task().get_task_no()
             cpu = event.get_cpu()
-            
+
             dummy = SPAN_START_EVENTS[event.__class__](task_no, cpu)
             dummy.corresp_start_event = event
             dummy.corresp_end_event = event.corresp_end_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)
-    
+
     def get_events(self, slots, list_type, event_types):
         for type in event_types:
             for slot in slots:
@@ -105,31 +105,31 @@ class TimeSlotArray(object):
                     if slot in self.array[list_type][no][type]:
                         for event in self.array[list_type][no][type][slot]:
                             yield event
-        
+
     def get_slots(self, slots, start, end, start_no, end_no, list_type):
         if self.array is None:
             return # empty schedule
-            
+
         if start > end:
             raise ValueError('Litmus is not a time machine')
         if start_no > end_no:
             raise ValueError('start no should be less than end no')
-            
+
         start_slot = self.get_time_slot(start)
         end_slot = self.get_time_slot(end) + 1
         start_no = max(0, start_no)
         end_no = min(self.list_sizes[list_type] - 1, end_no)
-        
+
         for slot in xrange(start_slot, end_slot + 1):
             if slot not in slots:
                 slots[slot] = {}
             for no in xrange(start_no, end_no + 1):
                 slots[slot][no] = None
-    
+
 class Schedule(object):
     """The total schedule (task system), consisting of a certain number of
     tasks."""
-    
+
     def __init__(self, name, num_cpus, task_list=[]):
         self.name = name
         self.tasks = {}
@@ -140,13 +140,13 @@ class Schedule(object):
         self.num_cpus = num_cpus
         for task in task_list:
             self.add_task(task)
-    
+
     def get_selected(self):
         return self.selected
-        
+
     def set_selected(self, selected):
         self.selected = selected
-    
+
     def add_selected(self, selected):
         for layer in selected:
             if layer not in self.selected:
@@ -156,35 +156,35 @@ class Schedule(object):
                     self.selected[layer][event] = {}
                 for graph in selected[layer][event]:
                     self.selected[layer][event][graph] = selected[layer][event][graph]
-            
+
     def remove_selected(self, selected):
         for layer in selected:
             if layer in self.selected:
                 for event in selected[layer]:
                     if event in self.selected[layer]:
                         del self.selected[layer][event]
-        
+
     def set_time_params(self, time_per_maj=None):
         self.time_per_maj = time_per_maj
         if self.time_per_maj is None:
             self.time_slot_array = TimeSlotArray()
             return
-            
+
         self.time_slot_array = TimeSlotArray(self.time_per_maj, \
                                                  len(self.task_list), self.num_cpus)
-            
+
     def get_time_slot_array(self):
         return self.time_slot_array
-    
+
     def get_time_bounds(self):
         return (self.start, self.end)
-        
+
     def scan(self, time_per_maj):
         self.start = None
         self.end = None
-        
+
         self.set_time_params(time_per_maj)
-        
+
         # we scan the graph task by task, and job by job
         for task_no, task in enumerate(self.get_task_list()):
             switches = {}
@@ -192,12 +192,12 @@ class Schedule(object):
                 switches[event] = None
             cur_cpu = [Event.NO_CPU]
             for job_no in sorted(task.get_jobs().keys()):
-                job = task.get_jobs()[job_no]    
+                job = task.get_jobs()[job_no]
                 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]:
                         event.scan(cur_cpu, switches)
-                        
+
             # What if one of the initial "span events" (switch to or inversion starting) never got a
             # corresponding end event? Well, then we assume that the end event was simply outside of
             # the range of whatever we read in. So we need to fill dummies starting from the initial
@@ -207,7 +207,7 @@ class Schedule(object):
                 event = switches[span_event]
                 if event is not None:
                     self.time_slot_array.fill_span_event_from_start(event)
-        
+
     def add_task(self, task):
         if task.name in self.tasks:
             raise ValueError("task already in list!")
@@ -216,29 +216,29 @@ class Schedule(object):
         task.schedule = self
         task.task_no = self.cur_task_no
         self.cur_task_no += 1
-    
+
     def get_tasks(self):
         return self.tasks
-        
+
     def get_task_list(self):
         return self.task_list
-    
+
     def get_name(self):
         return self.name
-    
+
     def get_num_cpus(self):
         return self.num_cpus
 
 def deepcopy_selected(selected):
     selected_copy = {}
     for layer in selected:
-        selected_copy[layer] = copy.copy(selected[layer])  
+        selected_copy[layer] = copy.copy(selected[layer])
     return selected_copy
-                   
+
 class Task(object):
     """Represents a task, including the set of jobs that were run under
     this task."""
-    
+
     def __init__(self, name, job_list=[]):
         self.name = name
         self.jobs = {}
@@ -246,25 +246,25 @@ class Task(object):
         self.schedule = None
         for job in job_list:
             self.add_job(job)
-        
+
     def add_job(self, job):
         if job.job_no in self.jobs:
             raise ScheduleError("a job is already being released at this time for this task")
         self.jobs[job.job_no] = job
         job.task = self
-    
+
     def get_schedule(self):
         return self.schedule
-        
+
     def get_jobs(self):
         return self.jobs
-    
+
     def get_task_no(self):
         return self.task_no
-        
+
     def get_name(self):
         return self.name
-            
+
 class Job(object):
     """Represents a job, including everything that happens related to the job"""
     def __init__(self, job_no, event_list=[]):
@@ -273,19 +273,19 @@ class Job(object):
         self.task = None
         for event in event_list:
             self.add_event(event)
-        
+
     def add_event(self, event):
         if event.time not in self.events:
             self.events[event.time] = []
         self.events[event.time].append(event)
         event.job = self
-    
+
     def get_events(self):
         return self.events
-    
+
     def get_task(self):
         return self.task
-    
+
     def get_job_no(self):
         return self.job_no
 
@@ -301,61 +301,73 @@ class DummyEvent(object):
         self.cpu = cpu
         self.job = None
         self.layer = None
-    
+
     def __str__(self):
         return '[Dummy Event]'
-            
+
     def get_time(self):
         return self.time
-        
+
     def get_cpu(self):
         return self.cpu
-        
+
     def get_job(self):
         return self.job
-    
+
     def get_layer(self):
         return self.layer
-        
+
     def render(self, graph, layer, prev_events, selectable=False):
         """Method that the visualizer calls to tell the event to render itself
         Obviously only implemented by subclasses (actual event types)
-        
+
         ``Rendering'' can mean either actually drawing the event or just
         adding it as a selectable region. This is controlled by the
         ``selectable'' parameter"""
         raise NotImplementdError
-        
+
 class Event(DummyEvent):
     """Represents an event that occurs while a job is running (e.g. get scheduled
     on a CPU, block, ...)"""
     NO_CPU = -1
     NUM_DEC_PLACES = 2
-    
+
     def __init__(self, time, cpu):
         super(Event, self).__init__(time, cpu)
         self.erroneous = False
-    
+
+    def get_name(self):
+        raise NotImplementedError
+
     def __str__(self):
-        return '[Event]'
-    
+        return self.get_name() + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
+
+    def str_long(self):
+        """Prints the event as a string, in ``long'' form."""
+        return 'Event Type: ' + self.get_name() + \
+                '\nTask Name: ' + str(self.get_job().get_task().get_name()) + \
+                '\n(Task no., Job no.): ' + str((self.get_job().get_task().get_task_no(), \
+                                                self.get_job().get_job_no())) + \
+                '\nCPU: ' + str(self.get_cpu()) + \
+                '\nTime: ' + str(self.get_time())
+
     def _common_str(self):
         job = self.get_job()
         task = job.get_task()
         return ' for task ' + str(task.get_name()) + ': (TASK, JOB)=' + str((task.get_task_no(), \
             job.get_job_no())) + ', CPU=' + str(self.get_cpu())
-            
+
     def is_erroneous(self):
         """An erroneous event is where something with the event is not quite right,
         something significantly wrong that we don't have logical information telling
         us how we should render the event."""
         return self.erroneous
-    
+
     def is_selected(self):
         """Returns whether the event has been selected by the user. (needed for rendering)"""
         selected = self.get_job().get_task().get_schedule().get_selected()
         return self.get_layer() in selected and self in selected[self.get_layer()]
-            
+
     def scan(self, cur_cpu, switches):
         """Part of the procedure that walks through all the events and sets
         some parameters that are unknown at first. For instance, a SwitchAwayEvent
@@ -370,26 +382,26 @@ class Event(DummyEvent):
             sched.start = time
         if sched.end is None or time > sched.end:
             sched.end = time
-        
+
         sched.get_time_slot_array().add_event_to_time_slot(self)
 
 class ErrorEvent(Event):
     pass
-                
+
 class SuspendEvent(Event):
     def __init__(self, time, cpu):
         super(SuspendEvent, self).__init__(time, cpu)
         self.layer = Canvas.MIDDLE_LAYER
-    
-    def __str__(self):
-        return 'Suspend' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
+
+    def get_name(self):
+        return 'Suspend'
+
     def scan(self, cur_cpu, switches):
         if self.get_cpu() != cur_cpu[0]:
             self.erroneous = True
             #fprint "suspending on a CPU different from the CPU we are on!"
         super(SuspendEvent, self).scan(cur_cpu, switches)
-            
+
     def render(self, graph, layer, prev_events, selectable=False):
         if layer == self.layer:
             prev_events[self] = None
@@ -399,22 +411,22 @@ class SuspendEvent(Event):
             else:
                 graph.draw_suspend_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                                 self.get_cpu(), self.is_selected())
-            
-        
+
+
 class ResumeEvent(Event):
     def __init__(self, time, cpu):
         super(ResumeEvent, self).__init__(time, cpu)
         self.layer = Canvas.MIDDLE_LAYER
-    
-    def __str__(self):
-        return 'Resume' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
+
+    def get_name(self):
+        return 'Resume'
+
     def scan(self, cur_cpu, switches):
         if cur_cpu[0] != Event.NO_CPU and cur_cpu[0] != self.get_cpu():
             self.erroneous = True
             #print "Resuming when currently scheduled on a CPU, but on a different CPU from the current CPU!"
         super(ResumeEvent, self).scan(cur_cpu, switches)
-        
+
     def render(self, graph, layer, prev_events, selectable=False):
         if layer == self.layer:
             prev_events[self] = None
@@ -424,19 +436,19 @@ class ResumeEvent(Event):
             else:
                 graph.draw_resume_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                                self.get_cpu(), self.is_selected())
-                
-        
+
+
 class CompleteEvent(Event):
     def __init__(self, time, cpu):
         super(CompleteEvent, self).__init__(time, cpu)
         self.layer = Canvas.TOP_LAYER
-    
-    def __str__(self):
-        return 'Complete' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
+
+    def get_name(self):
+        return 'Complete'
+
     def scan(self, cur_cpu, switches):
         super(CompleteEvent, self).scan(cur_cpu, switches)
-    
+
     def render(self, graph, layer, prev_events, selectable=False):
         if layer == Canvas.TOP_LAYER:
             prev_events[self] = None
@@ -452,27 +464,44 @@ class SwitchToEvent(Event):
         super(SwitchToEvent, self).__init__(time, cpu)
         self.layer = Canvas.BOTTOM_LAYER
         self.corresp_end_event = None
-        
+
+    def get_name(self):
+        if self.corresp_end_event is None:
+            return 'Switch To (w/o Switch Away)'
+        else:
+            return 'Scheduled'
+
     def __str__(self):
         if self.corresp_end_event is None:
-            return 'Switch To (w/o Switch Away)' + self._common_str() + ', TIME=' \
-                   + str(self.get_time())
-        return 'Scheduled' + self._common_str() + ', START=' \
+            return super(SwitchToEvent, self).__str__()
+        return self.get_name() + 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)
-        
+
+    def str_long(self):
+        if self.corresp_end_event is None:
+            return super(SwitchToEvent, self).str_long()
+        else :
+            return 'Event Type: ' + self.get_name() + \
+                '\nTask Name: ' + str(self.get_job().get_task().get_name()) + \
+                '\n(Task no., Job no.): ' + str((self.get_job().get_task().get_task_no(), \
+                                                self.get_job().get_job_no())) + \
+                '\nCPU: ' + str(self.get_cpu()) + \
+                '\nStart: ' + str(self.get_time()) + \
+                '\nEnd: ' + str(self.corresp_end_event.get_time())
+
     def scan(self, cur_cpu, switches):
         old_cur_cpu = cur_cpu[0]
         cur_cpu[0] = self.get_cpu()
         switches[SwitchToEvent] = self
         self.corresp_end_event = None
-        
+
         if old_cur_cpu != Event.NO_CPU:
             self.erroneous = True
             #print "currently scheduled somewhere, can't switch to a CPU"
-                            
+
         super(SwitchToEvent, self).scan(cur_cpu, switches)
-    
+
     def render(self, graph, layer, prev_events, selectable=False):
         if layer == self.layer:
             end_time = None
@@ -482,7 +511,7 @@ class SwitchToEvent(Event):
                 clip = AlignMode.RIGHT
             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()
@@ -493,30 +522,41 @@ class SwitchToEvent(Event):
                 graph.draw_bar_at_time(self.get_time(), end_time,
                                    task_no, cpu, self.get_job().get_job_no(),
                                    clip, self.is_selected())
-                                           
+
 class SwitchAwayEvent(Event):
     def __init__(self, time, cpu):
         super(SwitchAwayEvent, self).__init__(time, cpu)
         self.layer = Canvas.BOTTOM_LAYER
         self.corresp_start_event = None
-    
+
+    def get_name(self):
+        if self.corresp_start_event is None:
+            return 'Switch Away (w/o Switch To)'
+        else:
+            return 'Scheduled'
+
     def __str__(self):
         if self.corresp_start_event is None:
-            return 'Switch Away (w/o Switch To)' + self._common_str() + ', TIME=' \
-                   + str(self.get_time())
+            return super(SwitchAwayEvent, self).__str__()
         return str(self.corresp_start_event)
-            
+
+    def str_long(self):
+        if self.corresp_start_event is None:
+            return super(SwitchAwayEvent, self).str_long()
+
+        return self.corresp_start_event.str_long()
+
     def scan(self, cur_cpu, switches):
         old_cur_cpu = cur_cpu[0]
-        
+
         self.corresp_start_event = switches[SwitchToEvent]
-        
+
         cur_cpu[0] = Event.NO_CPU
         switches[SwitchToEvent] = None
-        
+
         if self.corresp_start_event is not None:
             self.corresp_start_event.corresp_end_event = self
-            
+
         if self.get_cpu() != old_cur_cpu:
             self.erroneous = True
             #print "switching away from a CPU different from the CPU we are currently on"
@@ -526,9 +566,9 @@ class SwitchAwayEvent(Event):
         elif self.get_time() < self.corresp_start_event.get_time():
             self.erroneous = True
             #print "switching away from a processor before we switched to it?!"
-        
+
         super(SwitchAwayEvent, self).scan(cur_cpu, switches)
-            
+
     def render(self, graph, layer, prev_events, selectable=False):
         if self.corresp_start_event is None:
             # We never found a corresponding start event. In that case, we can assume it lies
@@ -550,18 +590,18 @@ class SwitchAwayEvent(Event):
             if self.corresp_start_event in prev_events:
                 return # already rendered the bar
             self.corresp_start_event.render(graph, layer, prev_events, selectable)
-        
+
 class ReleaseEvent(Event):
     def __init__(self, time, cpu):
         super(ReleaseEvent, self).__init__(time, cpu)
         self.layer = Canvas.TOP_LAYER
-    
-    def __str__(self):
-        return 'Release' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-        
+
+    def get_name(self):
+        return 'Release'
+
     def scan(self, cur_cpu, switches):
         super(ReleaseEvent, self).scan(cur_cpu, switches)
-        
+
     def render(self, graph, layer, prev_events, selectable=False):
         prev_events[self] = None
         if layer == Canvas.TOP_LAYER:
@@ -571,19 +611,19 @@ class ReleaseEvent(Event):
             else:
                 graph.draw_release_arrow_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                              self.get_job().get_job_no(), self.is_selected())
-            
-                                             
+
+
 class DeadlineEvent(Event):
     def __init__(self, time, cpu):
         super(DeadlineEvent, self).__init__(time, cpu)
         self.layer = Canvas.TOP_LAYER
-    
-    def __str__(self):
-        return 'Deadline' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
+
+    def get_name(self):
+        return 'Deadline'
+
     def scan(self, cur_cpu, switches):
         super(DeadlineEvent, self).scan(cur_cpu, switches)
-        
+
     def render(self, graph, layer, prev_events, selectable=False):
         prev_events[self] = None
         if layer == Canvas.TOP_LAYER:
@@ -593,29 +633,46 @@ class DeadlineEvent(Event):
             else:
                 graph.draw_deadline_arrow_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                               self.get_job().get_job_no(), self.is_selected())
-            
+
 
 class InversionStartEvent(ErrorEvent):
     def __init__(self, time):
         super(InversionStartEvent, self).__init__(time, Event.NO_CPU)
         self.layer = Canvas.BOTTOM_LAYER
         self.corresp_end_event = None
-    
+
+    def get_name(self):
+        if self.corresp_end_event is None:
+            return 'Inversion Start (w/o Inversion End)'
+        else:
+            return 'Priority Inversion'
+
     def __str__(self):
         if self.corresp_end_event is None:
-            return 'Inversion Start (w/o Inversion End)' + self._common_str() \
-                  + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-        return 'Priority Inversion' + self._common_str() + ', START=' \
+            return super(InversionStartEvent, self).__str__()
+        return self.get_name() + 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)
-        
+
+    def str_long(self):
+        if self.corresp_end_event is None:
+            return super(InversionStartEvent, self).str_long()
+        else :
+            return 'Event Type: ' + self.get_name() + \
+                '\nTask Name: ' + str(self.get_job().get_task().get_name()) + \
+                '\n(Task no., Job no.): ' + str((self.get_job().get_task().get_task_no(), \
+                                                self.get_job().get_job_no())) + \
+                '\nCPU: ' + str(self.get_cpu()) + \
+                '\nStart: ' + str(self.get_time()) + \
+                '\nEnd: ' + str(self.corresp_end_event.get_time())
+
     def scan(self, cur_cpu, switches):
         switches[InversionStartEvent] = self
         self.corresp_end_event = None
-        
+
         # the corresp_end_event should already be set
         super(InversionStartEvent, self).scan(cur_cpu, switches)
-    
+
     def render(self, graph, layer, prev_events, selectable=False):
         if layer == self.layer:
             end_time = None
@@ -625,7 +682,7 @@ class InversionStartEvent(ErrorEvent):
                 clip = AlignMode.RIGHT
             else:
                 end_time = self.corresp_end_event.get_time()
-            
+
             if layer == self.layer:
                 prev_events[self] = None
                 cpu = self.get_cpu()
@@ -637,36 +694,47 @@ class InversionStartEvent(ErrorEvent):
                     graph.draw_mini_bar_at_time(self.get_time(), end_time,
                                      task_no, cpu, self.get_job().get_job_no(),
                                      clip, self.is_selected())
-            
+
 
 class InversionEndEvent(ErrorEvent):
     def __init__(self, time):
         super(InversionEndEvent, self).__init__(time, Event.NO_CPU)
         self.layer = Canvas.BOTTOM_LAYER
         self.corresp_start_event = None
-    
+
+    def get_name(self):
+        if self.corresp_start_event is None:
+            return 'Inversion End (w/o Inversion Start)'
+        else:
+            return 'Priority Inversion'
+
     def __str__(self):
         if self.corresp_start_event is None:
-            return 'Inversion End (w/o Inversion Start)' + self._common_str() \
-                  + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-        
+            return super(InversionEndEvent, self).__str__()
+
         return str(self.corresp_start_event)
-                      
+
+    def str_long(self):
+        if self.corresp_start_event is None:
+            return super(InversionEndEvent, self).str_long()
+
+        return self.corresp_start_event.str_long()
+
     def scan(self, cur_cpu, switches):
         self.corresp_start_event = switches[InversionStartEvent]
-        
+
         cur_cpu[0] = Event.NO_CPU
         switches[InversionStartEvent] = None
-        
+
         if self.corresp_start_event is not None:
             self.corresp_start_event.corresp_end_event = self
-            
+
         if self.corresp_start_event is None:
             self.erroneous = True
             #print "inversion end was not matched by a corresponding inversion start"
-        
+
         super(InversionEndEvent, self).scan(cur_cpu, switches)
-        
+
     def render(self, graph, layer, prev_events, selectable=False):
         if self.corresp_start_event is None:
             # We never found a corresponding start event. In that case, we can assume it lies
@@ -688,27 +756,27 @@ class InversionEndEvent(ErrorEvent):
             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 is None:
             if self.corresp_end_event in prev_events:
                 return # we have already been rendered
             self.corresp_end_event.render(graph, layer, prev_events, selectable)
-        else:    
+        else:
             if self.corresp_start_event in prev_events:
                 return # we have already been rendered
             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 is None:
             if self.corresp_end_event in prev_events:
diff --git a/unit_trace/viz/viewer.py b/unit_trace/viz/viewer.py
index 9b8502a..4d1fb7f 100644
--- a/unit_trace/viz/viewer.py
+++ b/unit_trace/viz/viewer.py
@@ -3,8 +3,8 @@
 """GUI stuff."""
 
 from schedule import *
-
 from renderer import *
+from windows import *
 
 import pygtk
 import gtk
@@ -13,145 +13,157 @@ import copy
 
 class GraphContextMenu(gtk.Menu):
     MAX_STR_LEN = 80
-    
-    def __init__(self, selected):
+
+    def __init__(self, selected, info_win):
         super(GraphContextMenu, self).__init__()
-        
+
+        self.info_win = info_win
+
         if not selected:
             item = gtk.MenuItem("(No events selected)")
             item.set_sensitive(False)
             self.append(item)
             item.show()
-        else:    
+        else:
             for layer in selected:
                 for event in selected[layer]:
                     string = str(event)
                     if len(string) > GraphContextMenu.MAX_STR_LEN - 3:
                         string = string[:GraphContextMenu.MAX_STR_LEN - 3] + '...'
                     item = gtk.MenuItem(string)
+                    item.connect('activate', self.update_info_window, event)
                     self.append(item)
                     item.show()
-        
+
+    def update_info_window(self, widget, data):
+        self.info_win.set_event(data)
+        self.info_win.present()
+
 class GraphArea(gtk.DrawingArea):
     HORIZ_PAGE_SCROLL_FACTOR = 10.8
     HORIZ_STEP_SCROLL_FACTOR = 0.8
     VERT_PAGE_SCROLL_FACTOR = 3.0
     VERT_STEP_SCROLL_FACTOR = 0.5
-    
+
     REFRESH_INFLATION_FACTOR = 4.0
-    
+
+    MIN_ZOOM_OUT = 0.25
+    MAX_ZOOM_IN = 4.0
+    ZOOM_INCR = 0.25
+
     def __init__(self, renderer):
         super(GraphArea, self).__init__()
-        
+
         self.renderer = renderer
-        
+
         self.cur_x = 0
         self.cur_y = 0
         self.width = 0
         self.height = 0
         self.scale = 1.0
-        
+
         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.EXPOSURE_MASK)
-        
+
         self.band_rect = None
         self.ctrl_clicked = False
         self.last_selected = {}
         self.dirtied_regions = []
-        
+
         self.connect('expose-event', self.expose)
         self.connect('size-allocate', self.size_allocate)
         self.connect('set-scroll-adjustments', self.set_scroll_adjustments)
         self.connect('button-press-event', self.button_press)
         self.connect('button-release-event', self.button_release)
         self.connect('motion-notify-event', self.motion_notify)
-        
+
     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, self.scale, ctx)
-        
-        # 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:
+
+        # If X caused the expose event, we need to update the entire area, not just the
+        # changes we might have made. An expose event caused by X needs to take priority
+        # over any expose events caused by updates to the state of the graph because
+        # the areas we marked as dirty only include the state changes, which is completely
+        # unrelated to the area that X indicates must be updated.
+        if expose_event.type == gtk.gdk.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.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
-        
+
     def get_graph(self):
         return self.renderer.get_graph()
-    
-    MIN_ZOOM_OUT = 0.25
-    MAX_ZOOM_IN = 4.0
-    ZOOM_INCR = 0.25
-    
+
+    def get_schedule(self):
+        return self.renderer.get_schedule()
+
     def zoom_in(self):
         scale = self.scale + GraphArea.ZOOM_INCR
         if scale > GraphArea.MAX_ZOOM_IN:
             scale = GraphArea.MAX_ZOOM_IN
         self.set_scale(scale)
-        
+
     def zoom_out(self):
         scale = self.scale - GraphArea.ZOOM_INCR
         if scale < GraphArea.MIN_ZOOM_OUT:
             scale = GraphArea.MIN_ZOOM_OUT
         self.set_scale(scale)
-        
+
     def set_scale(self, scale):
         if scale == self.scale:
             return
-            
+
         self.scale = scale
         self._dirty(0, 0, self.width, self.height)
-        
+
     def set_scroll_adjustments(self, widget, horizontal, vertical, data=None):
         graph = self.renderer.get_graph()
         width = graph.get_width()
         height = graph.get_height()
-        
+
         self.horizontal = horizontal
         self.vertical = vertical
         self.config_scrollbars(self.cur_x, self.cur_y)
-        
-        if self.horizontal is not None:                         
+
+        if self.horizontal is not None:
             self.horizontal.connect('value-changed', self.horizontal_value_changed)
         if self.vertical is not None:
             self.vertical.connect('value-changed', self.vertical_value_changed)
-        
+
     def horizontal_value_changed(self, adjustment):
         self.cur_x = min(adjustment.value, self.renderer.get_graph().get_width())
         self.cur_x = max(adjustment.value, 0.0)
-        
+
         self.renderer.get_graph().render_surface(self.renderer.get_schedule(), [(0, 0, self.width, self.height)], 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)
-        
+
         self.renderer.get_graph().render_surface(self.renderer.get_schedule(), [(0, 0, self.width, self.height)], True)
         self._dirty(0, 0, self.width, self.height)
-            
+
     def size_allocate(self, widget, allocation):
         self.width = allocation.width
         self.height = allocation.height
@@ -161,7 +173,7 @@ class GraphArea(gtk.DrawingArea):
         graph = self.renderer.get_graph()
         width = graph.get_width()
         height = graph.get_height()
-        
+
         if self.horizontal is not None:
             self.horizontal.set_all(hvalue, 0.0, width + self.width,
                                 graph.get_attrs().maj_sep * GraphArea.HORIZ_STEP_SCROLL_FACTOR,
@@ -169,8 +181,8 @@ class GraphArea(gtk.DrawingArea):
         if self.vertical is not None:
             self.vertical.set_all(vvalue, 0.0, height + self.height,
                                 graph.get_attrs().y_item_size * GraphArea.VERT_STEP_SCROLL_FACTOR,
-                                graph.get_attrs().y_item_size * GraphArea.VERT_PAGE_SCROLL_FACTOR, self.height) 
-    
+                                graph.get_attrs().y_item_size * GraphArea.VERT_PAGE_SCROLL_FACTOR, self.height)
+
     def refresh_events(self, sender, new, old, replace):
         """Even if the selected areas change on one graph, they change
         everywhere, and different events might be in different regions on
@@ -182,9 +194,9 @@ class GraphArea(gtk.DrawingArea):
         refreshes the drawing of the graph that requested the change."""
         if self is not sender:
             self.renderer.get_graph().render_events(new, True)
-        
+
         self._tag_events(new)
-        
+
         if self is sender:
             self._copy_tags(old)
             self._dirty_events(new)
@@ -194,14 +206,14 @@ class GraphArea(gtk.DrawingArea):
             else:
                 self.renderer.get_schedule().remove_selected(old)
                 self.renderer.get_schedule().add_selected(new)
-            
+
     def _find_max_layer(self, regions):
         max_layer = Canvas.BOTTOM_LAYER
         for event in regions:
             if event.get_layer() > max_layer:
                 max_layer = event.get_layer()
         return max_layer
-    
+
     def _dirty_events(self, events):
         # if an event changed selected status, update the bounding area
         for layer in events:
@@ -212,7 +224,7 @@ class GraphArea(gtk.DrawingArea):
                                 width * self.scale,
                                 height * self.scale,
                                 GraphFormat.BORDER_THICKNESS * self.scale)
-    
+
     def _tag_events(self, selected):
         """Some of the events in the collection of selected events might be new.
         In this case, these events are not yet associated with the region on
@@ -224,7 +236,7 @@ class GraphArea(gtk.DrawingArea):
                 # note that each graph has its own region associated
                 # with the event
                 selected[layer][event][self] = graph.get_sel_region(event)
-    
+
     def _copy_tags(self, selected):
         """When we want to specify a collection of selected events to perform
         an operation on, we usually do not know ahead of time what regions (in
@@ -235,21 +247,21 @@ class GraphArea(gtk.DrawingArea):
         for layer in selected:
             for event in selected[layer]:
                 selected[layer][event] = cur_selected[layer][event]
-        
+
     def _select_event(self, coll, event):
         if event.get_layer() not in coll:
             coll[event.get_layer()] = {}
         if event not in coll[event.get_layer()]:
             coll[event.get_layer()][event] = {}
-            
+
     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)
-                             
+
         just_selected = graph.get_selected_regions(motion_event.x, motion_event.y, 0, 0)
         was_selected = self.renderer.get_schedule().get_selected()
         if not just_selected:
@@ -257,38 +269,38 @@ class GraphArea(gtk.DrawingArea):
             the_event = None
         else:
             max_layer = self._find_max_layer(just_selected)
-        
+
             for event in just_selected:
                 if event.get_layer() == max_layer:
                     the_event = event
                     break
-            
+
             msg = str(the_event)
-        
+
         self.emit('update-event-description', the_event, msg)
-        
+
         if self.band_rect is not None:
             remove_selected = {}
             add_selected = {}
-                
+
             # dragging a rectangle
             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]
             old_x, old_y, old_width, old_height = self.band_rect
-            
+
             x_p, y_p, width_p, height_p = self._positivify(x, y, width, height)
             old_x_p, old_y_p, old_width_p, old_height_p = self._positivify(old_x, old_y, old_width, old_height)
             x_p, y_p, width_p, height_p = int(x_p), int(y_p), int(width_p), int(height_p)
             old_x_p, old_y_p, old_width_p, old_height_p = int(old_x_p), int(old_y_p), int(old_width_p), int(old_height_p)
-        
+
             new_reg = gtk.gdk.region_rectangle(gtk.gdk.Rectangle(x_p, y_p, width_p, height_p))
             old_reg = gtk.gdk.region_rectangle(gtk.gdk.Rectangle(old_x_p, old_y_p, old_width_p, old_height_p))
-            
+
             # To find the events that should be deselected and the new events that should be selected, compute
             # the set differences between the old and new selection rectangles
-            
+
             remove_reg = gtk.gdk.region_rectangle(gtk.gdk.Rectangle(old_x_p, old_y_p, old_width_p, old_height_p))
             remove_reg.subtract(new_reg)
             dirty_list = []
@@ -300,7 +312,7 @@ class GraphArea(gtk.DrawingArea):
                 for event in graph.get_selected_regions(rx, ry, rwidth, rheight):
                     if event.get_layer() in was_selected and event in was_selected[event.get_layer()]:
                         self._select_event(remove_selected, event)
-            
+
             add_reg = gtk.gdk.region_rectangle(gtk.gdk.Rectangle(x_p, y_p, width_p, height_p))
             add_reg.subtract(old_reg)
             dirty_list = [(x_p, y_p, width_p, 0), (x_p, y_p, 0, height_p),
@@ -312,38 +324,38 @@ class GraphArea(gtk.DrawingArea):
                 rx, ry, rwidth, rheight = rect
                 for event in graph.get_selected_regions(rx, ry, rwidth, rheight):
                     self._select_event(add_selected, event)
-            
+
             self.band_rect = x, y, width, height
             self.emit('request-refresh-events', self, add_selected, remove_selected, False)
-            
+
             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)
-    
+
     def button_press(self, widget, button_event, data=None):
         graph = self.renderer.get_graph()
-        
+
         self.ctrl_clicked = button_event.state & gtk.gdk.CONTROL_MASK
-        
+
         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)
-            
+
             just_selected = graph.get_selected_regions(button_event.x, button_event.y, 0, 0)
-            
+
             max_layer = self._find_max_layer(just_selected)
-            
+
             was_selected = self.renderer.get_schedule().get_selected()
             if not self.ctrl_clicked:
                 new_now_selected = {}
-                
+
                 more_than_one = 0
                 for layer in was_selected:
                     for event in was_selected[layer]:
                         more_than_one += 1
                         if more_than_one > 1:
                             break
-                            
+
                 # only select those events which were in the top layer (it's
                 # not intuitive to click something and then have something
                 # below it get selected). Also, clicking something that
@@ -353,12 +365,12 @@ class GraphArea(gtk.DrawingArea):
                         if not (more_than_one == 1 and event in was_selected):
                             self._select_event(new_now_selected, event)
                         break # only pick one event when just clicking
-            
+
                 self.emit('request-refresh-events', self, new_now_selected, was_selected, True)
             else:
                 remove_selected = {}
                 add_selected = {}
-                
+
                 for event in just_selected:
                     layer = event.get_layer()
                     if layer == max_layer:
@@ -367,39 +379,45 @@ class GraphArea(gtk.DrawingArea):
                         else:
                             self._select_event(add_selected, event)
                         break # again, only pick one event because we are just clicking
-                
+
                 self.emit('request-refresh-events', self, add_selected, remove_selected, False)
-                
+
             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
-        
+
         if button_event.button == 1:
             self._release_band()
-                    
+
+    def get_width(self):
+        return self.width
+
+    def get_height(self):
+        return self.height
+
     def _release_band(self):
         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, 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
@@ -407,17 +425,17 @@ class GraphArea(gtk.DrawingArea):
         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
@@ -425,53 +443,65 @@ class GraphArea(gtk.DrawingArea):
         if height < 0:
             y += height
             height = -height
-        
+
         return x, y, width, height
-        
-class GraphWindow(gtk.ScrolledWindow):    
+
+class GraphWindow(gtk.ScrolledWindow):
     def __init__(self, renderer):
         super(GraphWindow, self).__init__(None, None)
-        
+
         self.add_events(gtk.gdk.KEY_PRESS_MASK | gtk.gdk.SCROLL_MASK)
-        
+
         self.ctr = 0
         self.connect('key-press-event', self.key_press)
         self.connect('scroll-event', self.scroll)
-                                
+
         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
-        
+
         ctrl_clicked = key_event.state & gtk.gdk.CONTROL_MASK
-                     
+
         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:        
+        if key_event.keyval in keymap:
             keystr = keymap[key_event.keyval]
         else:
             return True
-                      
+
         if ctrl_clicked:
             keystr = 'ctrl-' + keystr
-            
+
         if keystr is not None:
             self._scroll_direction(keystr)
-            
+
         return True
-    
+
+    def set_hvalue(self, value):
+        if self.get_hadjustment() is None:
+            return
+
+        self.get_hadjustment().set_value(value)
+
+    def set_vvalue(self, value):
+        if self.get_vadjustment() is None:
+            return
+
+        self.get_vadjustment().set_value(value)
+
     def _scroll_direction(self, keystr):
         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()
@@ -484,7 +514,7 @@ class GraphWindow(gtk.ScrolledWindow):
         vpincr = vadj.get_page_increment()
         vsincr = vadj.get_step_increment()
         vpsize = vadj.get_page_size()
-        
+
         adj_tuple = {'up' :     (vadj, -vsincr, 0, vval, max),
                      'ctrl-up' :    (vadj, -vpincr, 0, vval, max),
                      'down' :   (vadj, vsincr, vupper - vpsize, vval, min),
@@ -493,10 +523,10 @@ class GraphWindow(gtk.ScrolledWindow):
                      'ctrl-left' :  (hadj, -hpincr, 0, hval, max),
                      'right' :  (hadj, hsincr, hupper - hpsize, hval, min),
                      'ctrl-right' : (hadj, hpincr, hupper - hpsize, hval, min)}
-        
+
         adj, inc, lim, val, extr = adj_tuple[keystr]
         adj.set_value(extr(val + inc, lim))
-        
+
     def scroll(self, widget, scroll_event):
         if scroll_event.state & gtk.gdk.CONTROL_MASK:
             if scroll_event.direction == gtk.gdk.SCROLL_UP:
@@ -508,106 +538,119 @@ class GraphWindow(gtk.ScrolledWindow):
                 self._scroll_direction('up')
             elif scroll_event.direction == gtk.gdk.SCROLL_DOWN:
                 self._scroll_direction('down')
-                
+
         return True
-                
+
     def get_graph_area(self):
         return self.garea
-                        
+
 class MainWindow(gtk.Window):
     WINDOW_WIDTH_REQ = 500
     WINDOW_HEIGHT_REQ = 300
-    
+
     def __init__(self):
         super(MainWindow, self).__init__(gtk.WINDOW_TOPLEVEL)
-        
+
         self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
-                        
+
         self.connect('delete_event', self.delete_event)
         self.connect('destroy', self.die)
-        
+
         file_menu = gtk.Menu()
         view_menu = gtk.Menu()
-        
+
         agr = gtk.AccelGroup()
         self.add_accel_group(agr)
-        
+
         quit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
         key, mod = gtk.accelerator_parse('Q')
         quit_item.add_accelerator('activate', agr, key, mod,
             gtk.ACCEL_VISIBLE)
         quit_item.connect('activate', self.quit_item_activate)
         quit_item.show()
-        
+
         file_menu.append(quit_item)
-        
+
         file_item = gtk.MenuItem('_File', True)
         file_item.set_submenu(file_menu)
         file_item.show()
-        
+
+        self.move_item = gtk.ImageMenuItem('_Move to Time')
+        key, mod = gtk.accelerator_parse('<Ctrl>M')
+        self.move_item.add_accelerator('activate', agr, key, mod,
+            gtk.ACCEL_VISIBLE)
+        self.move_item.set_sensitive(False)
+
+        self.move_item.connect('activate', self.move_to_time_activate)
+        self.move_item.show()
+
         zoom_in_item = gtk.ImageMenuItem(gtk.STOCK_ZOOM_IN, agr)
         key, mod = gtk.accelerator_parse('<Ctrl>plus')
         zoom_in_item.add_accelerator('activate', agr, key, mod,
             gtk.ACCEL_VISIBLE)
-        key, mod = gtk.accelerator_parse('<Ctrl>equal')  
-        zoom_in_item.add_accelerator('activate', agr, key, mod, 0) 
-        
+        key, mod = gtk.accelerator_parse('<Ctrl>equal')
+        zoom_in_item.add_accelerator('activate', agr, key, mod, 0)
+
         zoom_in_item.connect('activate', self.zoom_in_item_activate)
         zoom_in_item.show()
-        
+
         zoom_out_item = gtk.ImageMenuItem(gtk.STOCK_ZOOM_OUT, agr)
         key, mod = gtk.accelerator_parse('<Ctrl>minus')
         zoom_out_item.add_accelerator('activate', agr, key, mod,
             gtk.ACCEL_VISIBLE)
-        key, mod = gtk.accelerator_parse('<Ctrl>underscore')  
-        zoom_out_item.add_accelerator('activate', agr, key, mod, 0) 
-        
+        key, mod = gtk.accelerator_parse('<Ctrl>underscore')
+        zoom_out_item.add_accelerator('activate', agr, key, mod, 0)
+
         zoom_out_item.connect('activate', self.zoom_out_item_activate)
         zoom_out_item.show()
-        
+
+        view_menu.append(self.move_item)
         view_menu.append(zoom_in_item)
         view_menu.append(zoom_out_item)
-        
+
         view_item = gtk.MenuItem('_View', True)
         view_item.set_submenu(view_menu)
         view_item.show()
-        
+
         menu_bar = gtk.MenuBar()
         menu_bar.append(file_item)
         menu_bar.append(view_item)
-                
+
         menu_bar.show()
         self.vbox = gtk.VBox(False, 0)
-        
+
         self.notebook = gtk.Notebook()
-        
+
         self.notebook.last_page = -1
         self.notebook.connect('switch-page', self.switch_page)
-        
+
         self.notebook.show()
-        
+
         self.desc_label = gtk.Label('')
-        self.desc_label.set_justify(gtk.JUSTIFY_LEFT)
+        self.desc_label.set_alignment(0.0, 0.0)
         self.desc_label.show()
-        
+
         self.vbox.pack_start(menu_bar, False, False, 0)
         self.vbox.pack_start(self.notebook, True, True, 0)
         self.vbox.pack_start(self.desc_label, False, False, 0)
         self.vbox.show()
-        
+
         self.add(self.vbox)
-        
+
+        self.info_win = InfoWindow()
+
         self.set_size_request(MainWindow.WINDOW_WIDTH_REQ, MainWindow.WINDOW_HEIGHT_REQ)
-        
+
+        self.set_title('Unit-Trace Visualizer')
         self.show()
 
     def connect_widgets(self, gwindow):
-        gwindow.get_graph_area().connect('update-event-description', self.update_event_description)      
+        gwindow.get_graph_area().connect('update-event-description', self.update_event_description)
         gwindow.get_graph_area().connect('request-context-menu', self.request_context_menu)
         gwindow.get_graph_area().connect('request-refresh-events', self.request_refresh_events)
         gwindow.connect('request-zoom-in', self.zoom_in_item_activate)
         gwindow.connect('request-zoom-out', self.zoom_out_item_activate)
-        
+
     def set_renderers(self, renderers):
         for i in range(0, self.notebook.get_n_pages()):
             self.notebook.remove_page(0)
@@ -618,7 +661,13 @@ class MainWindow(gtk.Window):
             self.notebook.append_page(gwindow, gtk.Label(title))
         if self.notebook.get_n_pages() > 0:
             self.notebook.get_nth_page(0).grab_focus()
-        
+
+        if self.notebook.get_n_pages() > 0:
+            self.move_item.set_sensitive(True)
+        else:
+            self.move_item.set_sensitive(False)
+
+
     def switch_page(self, widget, page, page_num):
         if self.notebook.get_nth_page(self.notebook.last_page) is not None:
             old_value = self.notebook.get_nth_page(self.notebook.last_page).get_hadjustment().get_value()
@@ -626,44 +675,84 @@ class MainWindow(gtk.Window):
             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
-        
+
     def update_event_description(self, widget, event, msg):
         self.desc_label.set_text(msg)
-    
+
     def request_context_menu(self, widget, gdk_event, selected):
         button = 0
         if hasattr(gdk_event, 'button'):
            button = gdk_event.button
         time = gdk_event.time
-        
-        menu = GraphContextMenu(selected)
+
+        menu = GraphContextMenu(selected, self.info_win)
         menu.popup(None, None, None, button, time)
-    
+
     def request_refresh_events(self, widget, sender, old, new, replace):
         for i in range(0, self.notebook.get_n_pages()):
-            if self.notebook.get_nth_page(i).get_graph_area() is not sender: 
+            if self.notebook.get_nth_page(i).get_graph_area() is not sender:
                 self.notebook.get_nth_page(i).get_graph_area().refresh_events(sender, old, new, replace)
                 break
         for i in range(0, self.notebook.get_n_pages()):
-            if self.notebook.get_nth_page(i).get_graph_area() is sender: 
+            if self.notebook.get_nth_page(i).get_graph_area() is sender:
                 self.notebook.get_nth_page(i).get_graph_area().refresh_events(sender, old, new, replace)
-                        
+
+    def move_to_time_activate(self, widget):
+        dialog = TextInputDialog('Move to Time', 'What time to move to?', self)
+
+        err = True
+        while err:
+            ret = dialog.run()
+
+            if ret == gtk.RESPONSE_ACCEPT:
+                err, time = None, None
+                try:
+                    time = float(dialog.get_input())
+                    start, end = self.notebook.get_nth_page(0).get_graph_area().get_schedule().get_time_bounds()
+                    if time < start or time > end:
+                        err = 'Time out of range!'
+                except ValueError:
+                    err = 'Must input a number!'
+
+                if not err:
+                    for i in xrange(0, self.notebook.get_n_pages()):
+                        garea = self.notebook.get_nth_page(i).get_graph_area()
+                        # Center as much as possible
+                        pos = garea.get_graph().get_time_xpos(time) - garea.get_width() / 2.0
+                        pos = max(0, pos)
+                        pos = min(garea.get_graph().get_width(), pos)
+
+                        self.notebook.get_nth_page(i).set_hvalue(pos)
+                else:
+                    err_dialog = gtk.MessageDialog(self, gtk.DIALOG_DESTROY_WITH_PARENT,
+                                                         gtk.MESSAGE_ERROR,
+                                                         gtk.BUTTONS_CLOSE,
+                                                         err)
+                    err_dialog.set_title('Input Error')
+                    err_dialog.run()
+                    err_dialog.destroy()
+
+            else:
+                break
+
+        dialog.destroy()
+
     def zoom_in_item_activate(self, widget):
         for i in range(0, self.notebook.get_n_pages()):
             self.notebook.get_nth_page(i).get_graph_area().zoom_in()
-        
+
     def zoom_out_item_activate(self, widget):
         for i in range(0, self.notebook.get_n_pages()):
             self.notebook.get_nth_page(i).get_graph_area().zoom_out()
-        
+
     def quit_item_activate(self, widget):
         self.destroy()
-                    
+
     def delete_event(self, widget, event, data=None):
         return False
-        
+
     def die(self, widget, data=None):
         gtk.main_quit()
-    
+
diff --git a/unit_trace/viz/visualizer.py b/unit_trace/viz/visualizer.py
index 5027e89..c0186f7 100755
--- a/unit_trace/viz/visualizer.py
+++ b/unit_trace/viz/visualizer.py
@@ -1,9 +1,11 @@
 #!/usr/bin/python
 
-import viewer
 import convert
+import viewer
 import renderer
+import schedule
 import format
+import pygtk
 import gtk
 
 TIME_PER_MAJ = 10000000
@@ -11,13 +13,13 @@ TIME_PER_MAJ = 10000000
 def visualizer(stream):
     sched = convert.convert_trace_to_schedule(stream)
     sched.scan(TIME_PER_MAJ)
-    
+
     task_renderer = renderer.Renderer(sched)
     task_renderer.prepare_task_graph(attrs=format.GraphFormat(time_per_maj=TIME_PER_MAJ))
     cpu_renderer = renderer.Renderer(sched)
     cpu_renderer.prepare_cpu_graph(attrs=format.GraphFormat(time_per_maj=TIME_PER_MAJ))
-    
+
     window = viewer.MainWindow()
     window.set_renderers({'Tasks' : task_renderer, 'CPUs' : cpu_renderer})
-    
+
     gtk.main()
diff --git a/unit_trace/viz/windows.py b/unit_trace/viz/windows.py
new file mode 100644
index 0000000..4e5af5c
--- /dev/null
+++ b/unit_trace/viz/windows.py
@@ -0,0 +1,65 @@
+"""Module for various miscellanious GUI windows."""
+
+import pygtk
+import gtk
+import gobject
+
+class TextInputDialog(gtk.Dialog):
+    WINDOW_WIDTH_REQ = 250
+    WINDOW_HEIGHT_REQ = 100
+
+    def __init__(self, title, label, parent_window=None):
+        super(TextInputDialog, self).__init__(title, parent_window,
+                            gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
+                            (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
+                            gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
+        label_widget = gtk.Label(label)
+        label_widget.set_alignment(0.0, 0.0)
+        self.text_input = gtk.Entry()
+        label_widget.show()
+        self.text_input.show()
+
+        vbox = self.get_content_area()
+
+        vbox.pack_start(label_widget, False, False, 0)
+        vbox.pack_start(self.text_input, False, False, 0)
+        vbox.show()
+
+        self.set_resizable(False)
+
+        self.set_size_request(TextInputDialog.WINDOW_WIDTH_REQ, TextInputDialog.WINDOW_HEIGHT_REQ)
+
+    def get_input(self):
+        return self.text_input.get_text()
+
+class InfoWindow(gtk.Window):
+    """Window designed to show information about an event."""
+
+    WINDOW_WIDTH_REQ = 400
+    WINDOW_HEIGHT_REQ = 300
+
+    def __init__(self):
+        super(InfoWindow, self).__init__(gtk.WINDOW_TOPLEVEL)
+
+        self.frm = gtk.Frame()
+
+        self.connect('delete_event', gtk.Widget.hide_on_delete)
+
+        self.text_view = gtk.TextView()
+        self.text_view.set_editable(False)
+        self.text_view.show()
+        self.frm.add(self.text_view)
+        self.frm.show()
+
+        self.vbox = gtk.VBox(False, 0)
+        self.vbox.pack_start(self.frm, True, True, 0)
+        self.vbox.show()
+
+        self.add(self.vbox)
+
+        self.set_default_size(InfoWindow.WINDOW_WIDTH_REQ, InfoWindow.WINDOW_HEIGHT_REQ)
+        self.set_title('Event Details')
+
+    def set_event(self, event):
+        self.text_view.get_buffer().set_text(event.str_long())
+        self.frm.set_label('Details for ' + event.get_name())