Making sure everything committed

7 files changed, 1132 insertions, 807 deletions

diff --git a/unit_trace/viz/__init__.py b/unit_trace/viz/__init__.py
index 11505b9..8ba4784 100644
--- a/unit_trace/viz/__init__.py
+++ b/unit_trace/viz/__init__.py
@@ -12,5 +12,10 @@ gobject.signal_new('update-event-description', viewer.GraphArea, gobject.SIGNAL_
                         None, (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
 gobject.signal_new('request-context-menu', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
                         None, (gtk.gdk.Event, gobject.TYPE_PYOBJECT))
-#gobject.signal_new('request-renderer-change', viewer.MainWindow, gobject.SIGNAL_RUN_FIRST,
-#                        None, (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
+gobject.signal_new('request-refresh-events', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
+                        None, (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT,
+                               gobject.TYPE_PYOBJECT))
+gobject.signal_new('request-zoom-in', viewer.GraphWindow, gobject.SIGNAL_RUN_FIRST,
+                        None, ())
+gobject.signal_new('request-zoom-out', viewer.GraphWindow, gobject.SIGNAL_RUN_FIRST,
+                        None, ())
diff --git a/unit_trace/viz/draw.py b/unit_trace/viz/canvas.py
index 8c48744..758dea3 100644
--- a/unit_trace/viz/draw.py
+++ b/unit_trace/viz/canvas.py
@@ -1,12 +1,17 @@
 #!/usr/bin/python
 
+"""Classes related to the drawing and area-selection primitives. Note that
+this file is quite low-level, in that its objects are mostly restricted to
+dealing with drawing the components of a real-time graph given coordinates
+rather than having an abstract knowledge of the graph's measurements or
+any information about events."""
+
 import math
 import cairo
 import os
 import copy
 
 import util
-import schedule
 from format import *
 
 def snap(pos):
@@ -16,7 +21,7 @@ def snap(pos):
     line of width 1 on integer coordinates, it will come out blurry unless we shift it,
     since the line will get distributed over two pixels. We actually apply this to all
     coordinates to make sure everything is aligned."""
-    return pos
+    return pos - 0.5
 
 class Surface(object):
     def __init__(self, fname='temp', ctx=None):
@@ -25,6 +30,7 @@ class Surface(object):
         self.surface = None
         self.width = 0
         self.height = 0
+        self.scale = 1.0
         self.fname = fname
         self.ctx = ctx
     
@@ -39,9 +45,9 @@ class Surface(object):
         
     def write_out(self, fname):
         raise NotImplementedError
-    
+        
     def pan(self, x, y, width, height):
-        """A surface might actually represent just a ``window'' into
+        """A surface actually represents just a ``window'' into
         what we are drawing on. For instance, if we are scrolling through
         a graph, then the surface represents the area in the GUI window,
         not the entire graph (visible or not). So this method basically
@@ -51,6 +57,10 @@ 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)
@@ -58,7 +68,16 @@ class Surface(object):
         that we should draw to. Note that these might actually be outside the
         bounds of the surface,
         if we want something outside the surface's ``window''."""
-        return (x - self.virt_x, y - self.virt_y)
+        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):
@@ -164,9 +183,20 @@ class Canvas(object):
     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
@@ -315,17 +345,7 @@ 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_border_common(self, x, y, width, height, color, thickness, clip_side):
-        if clip_side is None:
-            self.draw_rect(x, y, width, height, color, thickness)
-        elif clip_side == AlignMode.LEFT:
-            self.draw_polyline([(x, y), (x + width, y), (x + width, y + height), (x, y + height)],
-                                color, thickness)
-        elif clip_side == AlignMode.RIGHT:
-            self.draw_polyline([(x + width, y), (x, y), (x, y + height), (x + width, y + height)],
-                                 color, thickness)
-                                 
+                          
     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."""
@@ -336,7 +356,7 @@ class Canvas(object):
         # use a pattern to be pretty
         self.get_bar_pattern(n).render_on_canvas(self, x, y, width, height, True)
         
-        self._draw_bar_border_common(x, y, width, height, color, thickness, clip_side)
+        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))
@@ -354,7 +374,7 @@ class Canvas(object):
         
         self.get_bar_pattern(n).render_on_canvas(self, x, y, width, height, True)
         
-        self._draw_bar_border_common(x, y, width, height, color, thickness, clip_side)
+        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))
@@ -494,23 +514,28 @@ class Canvas(object):
     
     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, real_x, real_y, width, height):
-        x = real_x + self.surface.virt_x
-        y = real_y + self.surface.virt_y
-        for event in self.selectable_regions.keys():
-            if self.selectable_regions[event].intersects(x, y, width, height):
-                del self.selectable_regions[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 = real_x + self.surface.virt_x
-        y = real_y + self.surface.virt_y
+        x, y = self.surface.get_virt_coor(real_x, real_y)
     
         selected = {}
         for event in self.selectable_regions:
@@ -520,10 +545,14 @@ class Canvas(object):
         
         return selected
         
-    def whiteout(self, real_x, real_y, width, height):
+    def whiteout(self):
         """Overwrites the surface completely white, but technically doesn't delete anything"""
-        self.fill_rect(self.surface.virt_x + real_x, self.surface.virt_y + real_y, width,
-                       height, (1.0, 1.0, 1.0), False)
+        # 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
@@ -569,19 +598,50 @@ class CairoCanvas(Canvas):
         """Gets the Surface that we are drawing on in its current state."""
         return self.surface
     
-    def _rect_common(self, x, y, width, height, color, thickness, do_snap=True):
+    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:
+            width += x
+            x = 0
+        if y < 0:
+            height += y
+            y = 0
+        if width > max_width:
+            width = max_width
+        if height > max_height:
+            height = max_height
+            
         if do_snap:
-            self.surface.ctx.rectangle(snap(x), snap(y), width, height)
+            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)
+            self.surface.ctx.line_to(x + width, y + height)
+            self.surface.ctx.line_to(x, y + height)
+        elif clip_side == AlignMode.RIGHT:
+            self.surface.ctx.move_to(x + width, y)
+            self.surface.ctx.line_to(x, y)
+            self.surface.ctx.line_to(x, y + height)
+            self.surface.ctx.line_to(x + width, y + height)
         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, do_snap=True):
-        self._rect_common(x, y, width, height, color, thickness, do_snap)
+    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):
@@ -605,7 +665,7 @@ class CairoCanvas(Canvas):
         if do_snap:
             self.surface.ctx.rectangle(snap(x), snap(y), width, height)
         else:
-            self.surface.ctx.rectangle(snap(x), snap(y), width, height)
+            self.surface.ctx.rectangle(x, y, width, height)
         self.surface.ctx.fill()
             
     def draw_line(self, p0, p1, color, thickness, do_snap=True):
@@ -625,7 +685,9 @@ class CairoCanvas(Canvas):
         self.surface.ctx.stroke()
         
     def _polyline_common(self, coor_list, color, thickness, do_snap=True):
-        real_coor_list = [self.surface.get_real_coor(coor[0], coor[1]) for coor in coor_list]
+        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)):
@@ -634,7 +696,7 @@ class CairoCanvas(Canvas):
         for coor in real_coor_list[1:]:
             self.surface.ctx.line_to(coor[0], coor[1])
         
-        self.surface.ctx.set_line_width(thickness)    
+        self.surface.ctx.set_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):
@@ -656,7 +718,7 @@ class CairoCanvas(Canvas):
         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.surface.ctx.set_font_size(fopts.size * self.scale)
         
         fe = self.surface.ctx.font_extents()
         f_ascent, f_descent, f_height = fe[:3]
@@ -728,6 +790,7 @@ class SelectableRegion(object):
         self.width = width
         self.height = height
         self.event = event
+        self.scale = 1.0
     
     def get_dimensions(self):
         return (self.x, self.y, self.width, self.height)
@@ -735,643 +798,12 @@ class SelectableRegion(object):
     def get_event(self):
         return self.event
     
-    def intersects(self, x, y, width, height):
-        return x <= self.x + self.width and x + width >= self.x and y <= self.y + self.height and y + height >= self.y
-        
-class Graph(object):
-    DEF_BAR_PLIST = [Pattern([(0.0, 0.9, 0.9)]), Pattern([(0.9, 0.3, 0.0)]), Pattern([(0.9, 0.7, 0.0)]),
-                     Pattern([(0.0, 0.0, 0.8)]), Pattern([(0.0, 0.2, 0.9)]), Pattern([(0.0, 0.6, 0.6)]),
-                     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
-        if start_time is None:
-            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
-
-        # We need to stretch the width in order to fit the y-axis labels. To do this we need
-        # the extents information, but we haven't set up a surface yet, so we just use a
-        # temporary one.
-        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:
-            dummy_surface.ctx.set_source_rgb(0.0, 0.0, 0.0)
-            te = dummy_surface.ctx.text_extents(item)
-            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 update_view(self, x, y, width, height, ctx):
-        """Proxy into the surface's pan."""
-        self.canvas.surface.pan(x, y, width, height)
-        self.canvas.surface.change_ctx(ctx)
-    
-    def _recomp_min_max(self, start_time, end_time, start_item, end_item):
-        if self.min_time is None or start_time < self.min_time:
-            self.min_time = start_time
-        if self.max_time is None or end_time > self.max_time:
-            self.max_time = end_time
-        if self.min_item is None or start_item < self.min_item:
-            self.min_item = start_item
-        if self.max_item is None or end_item > self.max_item:
-            self.max_item = end_item
-        
-    def _get_time_xpos(self, time):
-        """get x so that x is at instant ``time'' on the graph"""
-        return self.origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + 1.0 * (time - self.start_time) / self.attrs.time_per_maj * self.attrs.maj_sep
-    
-    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)     
-    
-    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) 
-    
-    def get_offset_params(self, real_x, real_y, width, height):
-        start_time = self.xcoor_to_time(self.canvas.surface.virt_x + real_x)
-        end_time = self.xcoor_to_time(self.canvas.surface.virt_x + real_x + width)
-        
-        start_item = self.ycoor_to_item_no(self.canvas.surface.virt_y + real_y)
-        end_item = 2 + self.ycoor_to_item_no(self.canvas.surface.virt_y + real_y + height)
+    def set_scale(self, scale):
+        self.scale = scale
         
-        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 render_events(self, event_list):
-        for layer in Canvas.LAYERS:
-            prev_events = {}
-            for event in event_list:
-                event.render(self, layer, prev_events)
-                        
-    def draw_axes(self, x_axis_label, y_axis_label):
-        """Draws and labels the axes according to the parameters that we were initialized
-        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,\
-                                self.attrs.maj_sep, self.attrs.min_per_maj, self.start_time, \
-                                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 certain 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 render_surface(self, sched, regions, selectable=False):
-        events_to_render = {}
-        for layer in Canvas.LAYERS:
-            events_to_render[layer] = {}
-        
-        for region in regions:
-            x, y, width, height = region
-            if not selectable:
-                self.canvas.whiteout(x, y, width, height)
-            else:
-                self.canvas.clear_selectable_regions(x, y, width, height)
-        
-        self.min_time, self.max_time, self.min_item, self.max_item = None, None, None, None  
-        for region in regions:
-            x, y, width, height = region
-            start_time, end_time, start_item, end_item = self.get_offset_params(x, y, width, height)
-            self._recomp_min_max(start_time, end_time, start_item, end_item)
-            
-            for event in sched.get_time_slot_array().iter_over_period(
-                        start_time, end_time, start_item, end_item,
-                        schedule.TimeSlotArray.TASK_LIST, schedule.EVENT_LIST):
-                events_to_render[event.get_layer()][event] = None
-        
-        if not selectable:
-            self.draw_skeleton(self.min_time, self.max_time,
-                               self.min_item, self.max_item)
-        
-        #if not selectable:
-        #    for layer in events_to_render:
-        #        print 'task render on layer', layer, ':', [str(e) for e in events_to_render[layer].keys()]
-            
-        for layer in Canvas.LAYERS:
-            prev_events = {}
-            for event in events_to_render[layer]:
-                event.render(self, layer, prev_events, selectable)
-        
-    def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
-        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
-        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
-        
-        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
-        
-        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
-        
-        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
-        
-        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
-        
-        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
-        
-        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
-        
-        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)
-        
-        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)
-        
-        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)
-        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)
-        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()
-        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()
-        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 render_surface(self, sched, regions, selectable=False):
-        BOTTOM_EVENTS = [schedule.ReleaseEvent, schedule.DeadlineEvent, schedule.InversionStartEvent,
-                     schedule.InversionEndEvent, schedule.InversionDummy]
-        TOP_EVENTS = [schedule.SuspendEvent, schedule.ResumeEvent, schedule.CompleteEvent,
-                  schedule.SwitchAwayEvent, schedule.SwitchToEvent, schedule.IsRunningDummy]
-                  
-        events_to_render = {}
-        for layer in Canvas.LAYERS:
-            events_to_render[layer] = {}
-        
-        self.min_time, self.max_time, self.min_item, self.max_item = None, None, None, None
-        for region in regions:
-            x, y, width, height = region
-            if not selectable:
-                #self.canvas.whiteout(x, y, width, height)
-                self.canvas.whiteout(0, 0, self.canvas.surface.width, self.canvas.surface.height)
-            else:
-                self.canvas.clear_selectable_regions(x, y, width, height)
-        
-        for region in regions:
-            x, y, width, height = region
-            start_time, end_time, start_item, end_item = self.get_offset_params(x, y, width, height)
-            self._recomp_min_max(start_time, end_time, start_item, end_item)
-            
-            for event in sched.get_time_slot_array().iter_over_period(
-                        start_time, end_time, start_item, end_item,
-                        schedule.TimeSlotArray.CPU_LIST,
-                        TOP_EVENTS):
-                events_to_render[event.get_layer()][event] = None
-        
-            if end_item >= len(self.y_item_list):
-                # we are far down enough that we should render the releases and deadlines and inversions,
-                # which appear near the x-axis
-                x, y, width, height = region
-                for event in sched.get_time_slot_array().iter_over_period(
-                        start_time, end_time, 0, sched.get_num_cpus(),
-                        schedule.TimeSlotArray.CPU_LIST,
-                        BOTTOM_EVENTS):
-                    events_to_render[event.get_layer()][event] = None
-        
-        if not selectable:
-            self.draw_skeleton(self.min_time, self.max_time,
-                               self.min_item, self.max_item)
-                                           
-        for layer in Canvas.LAYERS:
-            prev_events = {}
-            for event in events_to_render[layer]:
-                event.render(self, layer, prev_events, selectable)
-                
-    def render(self, schedule, start_time=None, end_time=None):
-        if end_time < start_time:
-            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
-        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
-        
-        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
-        
-        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
-        
-        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
-        
-        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
-        
-        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)
-        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)
-        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)
-        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)
-        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)
-        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
-            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):
-        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))
-        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))
-        width = self._get_bar_width(start_time, end_time)
-        height = self._get_mini_bar_height()
+    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
         
-        self.canvas.add_sel_mini_bar(x, y, width, height, event)
diff --git a/unit_trace/viz/graph.py b/unit_trace/viz/graph.py
new file mode 100644
index 0000000..6982e7c
--- /dev/null
+++ b/unit_trace/viz/graph.py
@@ -0,0 +1,657 @@
+import util
+import schedule
+from format import *
+from canvas import *
+
+"""The higher-level components of the rendering engine. The graph classes deal with more abstract dimensions
+than the canvas classes (time and task/cpu number rather than plain coordinates). Also, graphs know how to
+update themselves, unlike the Canvas which can only overwrite itself."""
+
+class Graph(object):
+    DEF_BAR_PLIST = [Pattern([(0.0, 0.9, 0.9)]), Pattern([(0.9, 0.3, 0.0)]), Pattern([(0.9, 0.7, 0.0)]),
+                     Pattern([(0.0, 0.0, 0.8)]), Pattern([(0.0, 0.2, 0.9)]), Pattern([(0.0, 0.6, 0.6)]),
+                     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
+        if start_time is None:
+            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
+
+        # We need to stretch the width in order to fit the y-axis labels. To do this we need
+        # the extents information, but we haven't set up a surface yet, so we just use a
+        # temporary one.
+        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:
+            dummy_surface.ctx.set_source_rgb(0.0, 0.0, 0.0)
+            te = dummy_surface.ctx.text_extents(item)
+            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
+        if self.max_time is None or end_time > self.max_time:
+            self.max_time = end_time
+        if self.min_item is None or start_item < self.min_item:
+            self.min_item = start_item
+        if self.max_item is None or end_item > self.max_item:
+            self.max_item = end_item
+        
+    def _get_time_xpos(self, time):
+        """get x so that x is at instant ``time'' on the graph"""
+        return self.origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + 1.0 * (time - self.start_time) / self.attrs.time_per_maj * self.attrs.maj_sep
+    
+    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)     
+    
+    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) 
+    
+    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."""    
+        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,\
+                                self.attrs.maj_sep, self.attrs.min_per_maj, self.start_time, \
+                                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  
+        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    
+        
+        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
+        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
+        
+        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
+        
+        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
+        
+        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
+        
+        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
+        
+        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
+        
+        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
+        
+        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)
+        
+        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)
+        
+        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)
+        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)
+        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()
+        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()
+        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  
+        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  
+        
+        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
+        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
+        
+        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
+        
+        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
+        
+        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
+        
+        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
+        
+        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)
+        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)
+        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)
+        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)
+        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)
+        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
+            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):
+        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))
+        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))
+        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 d94129c..4b231c4 100644
--- a/unit_trace/viz/renderer.py
+++ b/unit_trace/viz/renderer.py
@@ -1,6 +1,6 @@
 #!/usr/bin/python
 from schedule import *
-from draw import *
+from graph import *
 
 """The renderer, a glue object which converts a schedule to its representation
 on a graph."""
diff --git a/unit_trace/viz/schedule.py b/unit_trace/viz/schedule.py
index f134562..81269fa 100644
--- a/unit_trace/viz/schedule.py
+++ b/unit_trace/viz/schedule.py
@@ -5,7 +5,7 @@ the job releases and other events that have occurred for each task. This gives
 a high-level representation of a schedule that can be converted to, say, a
 graphic."""
 
-from draw import *
+from graph import *
 import util
 
 import copy
@@ -97,8 +97,16 @@ class TimeSlotArray(object):
             
             self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, dummy.__class__, slot, dummy)
             self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, dummy.__class__, slot, dummy)
-            
-    def iter_over_period(self, start, end, start_no, end_no, list_type, event_types):
+    
+    def get_events(self, slots, list_type, event_types):
+        for type in event_types:
+            for slot in slots:
+                for no in slots[slot]:
+                    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
             
@@ -106,19 +114,17 @@ class TimeSlotArray(object):
             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) + 2
-        
+        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 no in range(start_no, end_no + 1):
-            for type in event_types:
-                for slot in range(start_slot, end_slot):
-                    if slot in self.array[list_type][no][type]:
-                        for event in self.array[list_type][no][type][slot]:
-                            yield event
+        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
@@ -138,16 +144,26 @@ class Schedule(object):
     def get_selected(self):
         return self.selected
         
-    def set_selected(self, new_selected):
-        for event in self.selected:
-            event.selected = False
-        for event in new_selected:
-            event.selected = True
-        self.selected = new_selected
-    
-    def get_selected(self):
-        return copy.copy(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:
+                self.selected[layer] = {}
+            for event in selected[layer]:
+                if event not in self.selected:
+                    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:
@@ -212,7 +228,13 @@ class Schedule(object):
     
     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])  
+    return selected_copy
+                   
 class Task(object):
     """Represents a task, including the set of jobs that were run under
     this task."""
@@ -313,7 +335,6 @@ class Event(DummyEvent):
     def __init__(self, time, cpu):
         super(Event, self).__init__(time, cpu)
         self.erroneous = False
-        self.selected = False
     
     def __str__(self):
         return '[Event]'
@@ -332,7 +353,8 @@ class Event(DummyEvent):
     
     def is_selected(self):
         """Returns whether the event has been selected by the user. (needed for rendering)"""
-        return self.selected
+        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
@@ -480,7 +502,7 @@ class SwitchAwayEvent(Event):
     
     def __str__(self):
         if self.corresp_start_event is None:
-            return 'Switch Away (w/o Switch To)' + self._common_str() + 'TIME=' \
+            return 'Switch Away (w/o Switch To)' + self._common_str() + ', TIME=' \
                    + str(self.get_time())
         return str(self.corresp_start_event)
             
@@ -641,7 +663,7 @@ class InversionEndEvent(ErrorEvent):
             
         if self.corresp_start_event is None:
             self.erroneous = True
-            print "inversion end was not matched by a corresponding inversion start"
+            #print "inversion end was not matched by a corresponding inversion start"
         
         super(InversionEndEvent, self).scan(cur_cpu, switches)
         
diff --git a/unit_trace/viz/viewer.py b/unit_trace/viz/viewer.py
index 909da76..9b8502a 100644
--- a/unit_trace/viz/viewer.py
+++ b/unit_trace/viz/viewer.py
@@ -17,21 +17,28 @@ class GraphContextMenu(gtk.Menu):
     def __init__(self, selected):
         super(GraphContextMenu, self).__init__()
         
-        for event in selected:
-            string = str(event)
-            if len(string) > GraphContextMenu.MAX_STR_LEN - 3:
-                string = string[:GraphContextMenu.MAX_STR_LEN - 3] + '...'
-            item = gtk.MenuItem(string)
+        if not selected:
+            item = gtk.MenuItem("(No events selected)")
+            item.set_sensitive(False)
             self.append(item)
             item.show()
-            
+        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)
+                    self.append(item)
+                    item.show()
+        
 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 = 20.0
+    REFRESH_INFLATION_FACTOR = 4.0
     
     def __init__(self, renderer):
         super(GraphArea, self).__init__()
@@ -42,6 +49,7 @@ class GraphArea(gtk.DrawingArea):
         self.cur_y = 0
         self.width = 0
         self.height = 0
+        self.scale = 1.0
         
         self.set_set_scroll_adjustments_signal('set-scroll-adjustments')
         
@@ -50,6 +58,7 @@ class GraphArea(gtk.DrawingArea):
         
         self.band_rect = None
         self.ctrl_clicked = False
+        self.last_selected = {}
         self.dirtied_regions = []
         
         self.connect('expose-event', self.expose)
@@ -62,7 +71,7 @@ class GraphArea(gtk.DrawingArea):
     def expose(self, widget, expose_event, data=None):
         ctx = widget.window.cairo_create()
         graph = self.renderer.get_graph()
-        graph.update_view(self.cur_x, self.cur_y, self.width, self.height, ctx)
+        graph.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
@@ -91,7 +100,30 @@ class GraphArea(gtk.DrawingArea):
         
     def get_graph(self):
         return self.renderer.get_graph()
+    
+    MIN_ZOOM_OUT = 0.25
+    MAX_ZOOM_IN = 4.0
+    ZOOM_INCR = 0.25
+    
+    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()
@@ -110,12 +142,14 @@ class GraphArea(gtk.DrawingArea):
         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):
@@ -129,12 +163,38 @@ class GraphArea(gtk.DrawingArea):
         height = graph.get_height()
         
         if self.horizontal is not None:
-            self.horizontal.set_all(hvalue, 0.0, width, graph.get_attrs().maj_sep * GraphArea.HORIZ_STEP_SCROLL_FACTOR,
+            self.horizontal.set_all(hvalue, 0.0, width + self.width,
+                                graph.get_attrs().maj_sep * GraphArea.HORIZ_STEP_SCROLL_FACTOR,
                                 graph.get_attrs().maj_sep * GraphArea.HORIZ_PAGE_SCROLL_FACTOR, self.width)
         if self.vertical is not None:
-            self.vertical.set_all(vvalue, 0.0, height, graph.get_attrs().y_item_size * GraphArea.VERT_STEP_SCROLL_FACTOR,
+            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) 
     
+    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
+        different graphs. So when an event is selected on one graph its
+        region on a completely different graph needs to be updated. This
+        is why this method is here: given the graph that requested the
+        change, the old set of events selected, and the new set of events
+        selected, it updates the selected regions of this graph, and
+        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)
+            self._dirty_events(old)
+            if replace:
+                self.renderer.get_schedule().set_selected(new)
+            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:
@@ -142,17 +202,46 @@ class GraphArea(gtk.DrawingArea):
                 max_layer = event.get_layer()
         return max_layer
     
-    def _update_event_changes(self, list1, list2):
+    def _dirty_events(self, events):
         # if an event changed selected status, update the bounding area
-        for event in list1:
-            if event not in list2:
-                x, y, width, height = list1[event].get_dimensions()
-                self._dirty_inflate(x - self.cur_x, y - self.cur_y, width, height, GraphFormat.BORDER_THICKNESS)
-        for event in list2:
-            if event not in list1:
-                x, y, width, height = list2[event].get_dimensions()
-                self._dirty_inflate(x - self.cur_x, y - self.cur_y, width, height, GraphFormat.BORDER_THICKNESS)
-                        
+        for layer in events:
+            for event in events[layer]:
+                x, y, width, height = events[layer][event][self].get_dimensions()
+                self._dirty_inflate((x - self.cur_x) * self.scale,
+                                (y - self.cur_y) * self.scale,
+                                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
+        the graph that they belong to. This method fixes this.
+        """
+        graph = self.renderer.get_graph()
+        for layer in selected:
+            for event in selected[layer]:
+                # 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
+        which graphs) the events are associated with. But we have this information
+        stored in the collection of all selected events. This method just copies
+        this information over to the selected variable."""
+        cur_selected = self.renderer.get_schedule().get_selected()
+        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
         
@@ -160,7 +249,9 @@ class GraphArea(gtk.DrawingArea):
         
         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:
             msg = ''
             the_event = None
@@ -177,30 +268,57 @@ class GraphArea(gtk.DrawingArea):
         self.emit('update-event-description', the_event, msg)
         
         if self.band_rect is not None:
-            selected = {}
-            was_selected = self.renderer.get_schedule().get_selected()
-            if self.ctrl_clicked:
-                selected = copy.copy(was_selected)
+            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)
-            graph.render_surface(self.renderer.get_schedule(), [(x_p, y_p, width_p, height_p)], True)
-            selected.update(graph.get_selected_regions(x_p, y_p, width_p, height_p))
-            self.renderer.get_schedule().set_selected(selected)
-    
-            old_x, old_y, old_width, old_height = self.band_rect
-            self.band_rect = (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 = []
+            for rect in remove_reg.get_rectangles():
+                dirty_list.append((rect.x, rect.y, rect.width, rect.height))
+            graph.render_surface(self.renderer.get_schedule(), dirty_list, True)
+            for rect in dirty_list:
+                rx, ry, rwidth, rheight = rect
+                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),
+                          (x_p, y_p + height_p, width_p, 0), (x_p + width_p, y_p, 0, height_p)]
+            for rect in add_reg.get_rectangles():
+                dirty_list.append((rect.x, rect.y, rect.width, rect.height))
+            graph.render_surface(self.renderer.get_schedule(), dirty_list, True)
+            for rect in dirty_list:
+                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)
-        
-            self._update_event_changes(was_selected, selected)
-            
+    
     def button_press(self, widget, button_event, data=None):
         graph = self.renderer.get_graph()
         
@@ -215,34 +333,43 @@ class GraphArea(gtk.DrawingArea):
             
             max_layer = self._find_max_layer(just_selected)
             
-            new_now_selected = None
             was_selected = self.renderer.get_schedule().get_selected()
-            if self.ctrl_clicked:
-                new_now_selected = copy.copy(was_selected)
-            else:
+            if not self.ctrl_clicked:
                 new_now_selected = {}
                 
-            # 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
-            # is selected deselects it, if it's the only thing selected
-            for event in just_selected:
-                if event.get_layer() == max_layer:
-                    val = True
-                    now_selected = self.renderer.get_schedule().get_selected()
-                    if (len(now_selected) == 1 or self.ctrl_clicked) and event in now_selected:
-                        val = not event.is_selected
-                    if val:
-                        new_now_selected[event] = graph.get_sel_region(event)
-                    elif event in new_now_selected:
-                        del new_now_selected[event]
-                    break # only pick one event when just clicking
-            
-            self.renderer.get_schedule().set_selected(new_now_selected)
-            #self.last_selected = new_now_selected
-            
-            self._update_event_changes(new_now_selected, was_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
+                # is selected deselects it, if it's the only thing selected
+                for event in just_selected:
+                    if event.get_layer() == max_layer:
+                        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:
+                        if layer in was_selected and event in was_selected[layer]:
+                            self._select_event(remove_selected, event)
+                        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)
                     
@@ -252,11 +379,10 @@ class GraphArea(gtk.DrawingArea):
                                     
     def button_release(self, widget, button_event, data=None):
         self.ctrl_clicked = False
-        #self.last_selected = copy.copy(self.renderer.get_schedule().get_selected())
         
         if button_event.button == 1:
             self._release_band()
-    
+                    
     def _release_band(self):
         if self.band_rect is not None:
             x, y, width, height = self.band_rect
@@ -306,20 +432,45 @@ class GraphWindow(gtk.ScrolledWindow):
     def __init__(self, renderer):
         super(GraphWindow, self).__init__(None, None)
         
-        self.add_events(gtk.gdk.KEY_PRESS_MASK)
+        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:        
+            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 _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()
@@ -334,8 +485,6 @@ class GraphWindow(gtk.ScrolledWindow):
         vsincr = vadj.get_step_increment()
         vpsize = vadj.get_page_size()
         
-        ctrl_clicked = key_event.state & gtk.gdk.CONTROL_MASK
-        
         adj_tuple = {'up' :     (vadj, -vsincr, 0, vval, max),
                      'ctrl-up' :    (vadj, -vpincr, 0, vval, max),
                      'down' :   (vadj, vsincr, vupper - vpsize, vval, min),
@@ -344,22 +493,24 @@ 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)}
-                     
-        keystr = None
-        keymap = {gtk.keysyms.Up : 'up', gtk.keysyms.Down : 'down',
-                  gtk.keysyms.Left : 'left', gtk.keysyms.Right : 'right'}
-        if key_event.keyval in keymap:        
-            keystr = keymap[key_event.keyval]
-                  
-        if ctrl_clicked:
-            keystr = 'ctrl-' + keystr
-            
-        if keystr is not None:
-            adj, inc, lim, val, extr = adj_tuple[keystr]
-            adj.set_value(extr(val + inc, lim))
-            
-        return True
         
+        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:
+                self.emit('request-zoom-in')
+            elif scroll_event.direction == gtk.gdk.SCROLL_DOWN:
+                self.emit('request-zoom-out')
+        else:
+            if scroll_event.direction == gtk.gdk.SCROLL_UP:
+                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
                         
@@ -370,38 +521,76 @@ class MainWindow(gtk.Window):
     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)
         
-        self.file_menu = gtk.Menu()
-        self.quit_item = gtk.MenuItem('_Quit', True)
-        self.quit_item.connect('activate', self.quit_item_activate)
-        self.quit_item.show()
-        self.file_menu.append(self.quit_item)
+        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()
+        
+        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) 
         
-        self.file_item = gtk.MenuItem('_File', True)
-        self.file_item.set_submenu(self.file_menu)
-        self.file_item.show()
+        zoom_in_item.connect('activate', self.zoom_in_item_activate)
+        zoom_in_item.show()
         
-        self.menu_bar = gtk.MenuBar()
-        self.menu_bar.append(self.file_item)
+        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) 
         
-        self.menu_bar.show()
+        zoom_out_item.connect('activate', self.zoom_out_item_activate)
+        zoom_out_item.show()
         
+        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.show()
         
-        self.vbox.pack_start(self.menu_bar, False, False, 0)
+        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()
@@ -412,18 +601,23 @@ class MainWindow(gtk.Window):
         
         self.show()
 
-    def connect_widgets(self, garea):
-        garea.connect('update-event-description', self.update_event_description)      
-        garea.connect('request-context-menu', self.request_context_menu)
-    
+    def connect_widgets(self, gwindow):
+        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)
         for title in renderers:
             gwindow = GraphWindow(renderers[title])
-            self.connect_widgets(gwindow.get_graph_area())
+            self.connect_widgets(gwindow)
             gwindow.show()
             self.notebook.append_page(gwindow, gtk.Label(title))
+        if self.notebook.get_n_pages() > 0:
+            self.notebook.get_nth_page(0).grab_focus()
         
     def switch_page(self, widget, page, page_num):
         if self.notebook.get_nth_page(self.notebook.last_page) is not None:
@@ -432,7 +626,7 @@ 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):
@@ -446,10 +640,27 @@ class MainWindow(gtk.Window):
         
         menu = GraphContextMenu(selected)
         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: 
+                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: 
+                self.notebook.get_nth_page(i).get_graph_area().refresh_events(sender, old, new, replace)
+                        
+    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
         
diff --git a/unit_trace/viz/visualizer.py b/unit_trace/viz/visualizer.py
index d739736..5027e89 100755
--- a/unit_trace/viz/visualizer.py
+++ b/unit_trace/viz/visualizer.py
@@ -1,7 +1,5 @@
 #!/usr/bin/python
 
-"""."""
-
 import viewer
 import convert
 import renderer