Colorsgit add .! COLORSgit add .git add .geany index.txt

8 files changed, 901 insertions, 358 deletions

diff --git a/test.png b/test.png
new file mode 100644
index 0000000..ab2ebc0
--- /dev/null
+++ b/test.png
diff --git a/unit_trace/viz/__init__.py b/unit_trace/viz/__init__.py
index 99ed99e..592f697 100644
--- a/unit_trace/viz/__init__.py
+++ b/unit_trace/viz/__init__.py
@@ -19,6 +19,8 @@ gobject.signal_new('set-scroll-adjustments', viewer.GraphArea, gobject.SIGNAL_RU
                         None, (gtk.Adjustment, gtk.Adjustment))
 gobject.signal_new('update-event-description', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
                         None, (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
+gobject.signal_new('update-sel-changes', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
+                        None, (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-refresh-events', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
diff --git a/unit_trace/viz/canvas.py b/unit_trace/viz/canvas.py
index ea73d98..9ac0e8b 100644
--- a/unit_trace/viz/canvas.py
+++ b/unit_trace/viz/canvas.py
@@ -1,9 +1,9 @@
 #!/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
+"""Classes related to the drawing and area-selection primitives. This module
+is quite low-level, in that its objects are mostly restricted to
+dealing with just drawing the components of a real-time graph at specific
+coordinates, rather than having any knowledge of the graph's measurements or
 any information about events."""
 
 import math
@@ -14,16 +14,9 @@ import copy
 import util
 from format import *
 
-def snap(pos):
-    """Takes in an x- or y-coordinate ``pos'' and snaps it to the pixel grid.
-    This is necessary because integer coordinates in Cairo actually denote
-    the spaces between pixels, not the pixels themselves, so if we draw a
-    line of width 1 on integer coordinates, it will come out blurry unless we shift it,
-    since the line will get distributed over two pixels. We actually apply this to all
-    coordinates to make sure everything is aligned."""
-    return pos - 0.5
-
 class Surface(object):
+    """Represents the actual surface that gets drawn on. Its size is the size of the
+    area that the user actually sees."""
     def __init__(self, fname='temp', ctx=None):
         self.virt_x = 0
         self.virt_y = 0
@@ -40,9 +33,6 @@ class Surface(object):
     def change_ctx(self, ctx):
         self.ctx = ctx
 
-    def get_fname(self):
-        return self.fname
-
     def write_out(self, fname):
         raise NotImplementedError
 
@@ -57,7 +47,7 @@ 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
@@ -83,9 +73,11 @@ class SVGSurface(Surface):
     def renew(self, width, height):
         iwidth = int(math.ceil(width))
         iheight = int(math.ceil(height))
+        self.width = width
+        self.height = height
         self.surface = cairo.SVGSurface(self.fname, iwidth, iheight)
         self.ctx = cairo.Context(self.surface)
-
+        
     def write_out(self, fname):
         os.execl('cp', self.fname, fname)
 
@@ -93,12 +85,14 @@ class ImageSurface(Surface):
     def renew(self, width, height):
         iwidth = int(math.ceil(width))
         iheight = int(math.ceil(height))
+        self.width = width
+        self.height = height
         self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, iwidth, iheight)
         self.ctx = cairo.Context(self.surface)
-
+        
     def write_out(self, fname):
         if self.surface is None:
-            raise ValueError('Don\'t own surface, can\'t write to to file')
+            raise ValueError("Don't own surface, can't write to file")
 
         self.surface.write_to_png(fname)
 
@@ -110,6 +104,9 @@ class Pattern(object):
         self.color_list = color_list
         self.stripe_size = stripe_size
 
+    def get_color_list(self):
+        return self.color_list
+        
     def render_on_canvas(self, canvas, x, y, width, height, fade=False):
         fade_span = min(width, Pattern.MAX_FADE_WIDTH)
 
@@ -169,7 +166,8 @@ class Canvas(object):
         or filling in bars, respectively."""
 
         self.surface = surface
-
+        self.def_surface = None
+        
         self.width = int(math.ceil(width))
         self.height = int(math.ceil(height))
         self.item_clist = item_clist
@@ -179,15 +177,28 @@ class Canvas(object):
 
         self.scale = 1.0
 
-    # clears the canvas.
-    def clear(self):
-        raise NotImplementedError
-
+    def set_tmp_surface(self, surface):
+        """Changes to a temporary surface, used, perhaps, for printing
+        or drawing to a file."""
+        if self.def_surface is not None:
+            raise ValueError
+            
+        self.def_surface = self.surface
+        self.surface = surface
+        
+    def revert_surface(self):
+        """Goes back to the default surface; that is, the one used for
+        drawing to the screen."""
+        if self.def_surface is not None:
+            self.surface = self.def_surface
+            self.def_surface = None
+        
     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)
+        for layer in self.selectable_regions:
+            for event in self.selectable_regions[layer]:
+                self.selectable_regions[layer][event].set_scale(scale)
 
     def scaled(self, *coors):
         """Scales a series of coordinates."""
@@ -241,24 +252,6 @@ class Canvas(object):
 
         self.draw_line((x, y), (x, y - height), (0.0, 0.0, 0.0), GraphFormat.AXIS_THICKNESS)
 
-    def draw_y_axis_labels(self, x, y, height, item_list, item_size, fopts=None):
-        """Draws the item labels on the y-axis. ``item_list'' is the list
-        of strings to print, while item_size gives the vertical amount of
-        space that each item shall take up, in pixels."""
-        if fopts is None:
-            fopts = GraphFormat.DEF_FOPTS_ITEM
-
-        x -= GraphFormat.Y_AXIS_ITEM_GAP
-        y -= height - item_size / 2.0
-
-        orig_color = fopts.color
-        for ctr, item in enumerate(item_list):
-            fopts.color = self.get_item_color(ctr)
-            self.draw_label(item, x, y, fopts, AlignMode.RIGHT, AlignMode.CENTER)
-            y += item_size
-
-        fopts.color = orig_color
-
     def draw_x_axis(self, x, y, start_tick, end_tick, maj_sep, min_per_maj):
         """Draws the x-axis, including all the major and minor ticks (but not the labels).
         ``num_maj'' gives the number of major ticks, ``maj_sep'' the number of pixels between
@@ -295,7 +288,7 @@ class Canvas(object):
         minincr = incr / (min_per_maj * 1.0)
 
         cur = start * 1.0
-
+        
         for i in range(start_tick, end_tick + 1):
             text = util.format_float(cur, 2)
             self.draw_label(text, x, y, majfopts, AlignMode.CENTER, AlignMode.TOP)
@@ -358,6 +351,87 @@ class Canvas(object):
 
         self.draw_rect(x, y, width, height, color, thickness, clip_side)
 
+    def draw_y_axis_item(self, x, y, axis_height, item, item_no, item_size, selected, fopts=None):
+        """Draws the item labels on the y-axis. ``item'' is the string to print,
+        while item_size gives the vertical amount of
+        space that each item shall take up, in pixels."""
+        if fopts is None:
+            fopts = GraphFormat.DEF_FOPTS_ITEM
+
+        x -= GraphFormat.Y_AXIS_ITEM_GAP
+        y -= axis_height - item_size / 2.0 - item_size * item_no
+
+        orig_color = fopts.color
+        
+        if selected:
+            fopts.color = GraphFormat.HIGHLIGHT_COLOR
+        else:
+            fopts.color = self.get_item_color(item_no)
+        self.draw_label(item, x, y, fopts, AlignMode.RIGHT, AlignMode.CENTER)
+
+        fopts.color = orig_color
+    
+    def add_sel_y_axis_item(self, x, y, axis_height, item, item_no, item_size, event, fopts=None):
+        if fopts is None:
+            fopts = GraphFormat.DEF_FOPTS_ITEM
+            
+        x -= GraphFormat.Y_AXIS_ITEM_GAP
+        y -= axis_height - item_size / 2.0 - item_size * item_no
+        
+        x, y, width, height, f_height = self.get_label_dim(item, x, y, fopts, AlignMode.RIGHT, AlignMode.CENTER, False)
+        #(x, y) gives bottom-left, not top-left
+        y -= height
+        self.add_sel_region(SelectableRegion(x, y, width, height, event))
+        
+    def draw_top_item(self, x, y, axis_height, item, item_no, prev_items, selected, fopts=None):
+        """Draws the item labels at the top. ``item'' is the string to print,
+        while item_size gives the vertical amount of
+        space that each item shall take up, in pixels. ``prev_items'' is the set
+        of items to be printed before this item (although this method prints only
+        ``item'', ``prev_item'' is needed to find the proper offset"""
+        if fopts is None:
+            fopts = GraphFormat.DEF_FOPTS_ITEM
+
+        y -= axis_height + GraphFormat.TOP_ITEM_VERT_GAP
+        
+        for prev_item in prev_items:
+            x += GraphFormat.TOP_ITEM_HORIZ_GAP + self.get_label_dim(prev_item, x, y, fopts,
+                                                AlignMode.LEFT, AlignMode.TOP)[2]
+            
+        orig_color = fopts.color
+        
+        if selected:
+            fopts.color = GraphFormat.HIGHLIGHT_COLOR
+        else:
+            fopts.color = self.get_bar_pattern(item_no).get_color_list()[0]
+        
+        self.draw_label(item, x, y, fopts, AlignMode.LEFT, AlignMode.BOTTOM)
+        
+        fopts.color = orig_color
+        
+    def add_sel_top_item(self, x, y, axis_height, item, item_no, prev_items, event, fopts=None):
+        """Draws the item labels at the top. ``item'' is the string to print,
+        while item_size gives the vertical amount of
+        space that each item shall take up, in pixels. ``prev_items'' is the set
+        of items to be printed before this item (although this method prints only
+        ``item'', ``prev_item'' is needed to find the proper offset"""
+        if fopts is None:
+            fopts = GraphFormat.DEF_FOPTS_ITEM
+
+        y -= axis_height + GraphFormat.TOP_ITEM_VERT_GAP
+        
+        for item in prev_items:
+            x += GraphFormat.TOP_ITEM_HORIZ_GAP + self.get_label_dim(item, x, y, fopts,
+                                                AlignMode.LEFT, AlignMode.BOTTOM)[2]
+        
+        x, y, width, height, f_height = self.get_label_dim(item, x, y, fopts, AlignMode.LEFT, AlignMode.BOTTOM, False)
+        #(x, y) gives bottom-left, not top-left
+        y -= height
+        self.add_sel_region(SelectableRegion(x, y, width, height, event))
+        
+    def add_sel_dummy(self, event):
+        self.add_sel_region(SelectableRegion(None, None, None, None, event))
+            
     def add_sel_bar(self, x, y, width, height, event):
         self.add_sel_region(SelectableRegion(x, y, width, height, event))
 
@@ -518,30 +592,31 @@ class Canvas(object):
     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
+        layer = region.get_event().get_layer()
+        if layer not in self.selectable_regions:
+            self.selectable_regions[layer] = {}
+        self.selectable_regions[layer][region.get_event()] = region
 
     def get_sel_region(self, event):
-        return self.selectable_regions[event]
+        return self.selectable_regions[event.get_layer()][event]
 
     def has_sel_region(self, event):
-        return event in self.selectable_regions
+        return event.get_layer() in self.selectable_regions \
+               and event in self.selectable_regions[event.get_layer()]
 
-    def get_selected_regions(self, real_x, real_y, width, height):
+    def get_intersecting_regions(self, real_x, real_y, width, height):
         x, y = self.surface.get_virt_coor(real_x, real_y)
 
         selected = {}
-        for event in self.selectable_regions:
-            region = self.selectable_regions[event]
-            if region.intersects(x, y, width, height):
-                selected[event] = region
+        for layer in self.selectable_regions:
+            for event in self.selectable_regions[layer]:
+                region = self.selectable_regions[layer][event]
+                if region.intersects(x, y, width, height):
+                    if layer not in selected:
+                        selected[layer] = {}
+                    selected[layer][event] = region
 
         return selected
 
@@ -551,25 +626,21 @@ class Canvas(object):
 
         x, y = self.surface.get_virt_coor_unscaled(0, 0)
         width, height = self.unscaled(self.surface.width, self.surface.height)
-
+        
         self.fill_rect(x, y, width, height, (1.0, 1.0, 1.0), False)
 
     def get_item_color(self, n):
-        """Gets the nth color in the item color list, which are the colors used to draw the items
-        on the y-axis. Note that there are conceptually infinitely
-        many patterns because the patterns repeat -- that is, we just mod out by the size of the pattern
-        list when indexing."""
-        return self.item_clist[n % len(self.item_clist)]
-
+        return self.item_clist[n]
+        
     def get_bar_pattern(self, n):
-        """Gets the nth pattern in the bar pattern list, which is a list of surfaces that are used to
-        fill in the bars. Note that there are conceptually infinitely
-        many patterns because the patterns repeat -- that is, we just mod out by the size of the pattern
-        list when indexing."""
-        if n < 0:
-            return self.bar_plist[-1]
-        return self.bar_plist[n % (len(self.bar_plist) - 1)]
-
+        return self.bar_plist[n]
+    
+    def set_item_color(self, n, color):
+        self.item_clist[n] = color
+        
+    def set_bar_pattern(self, n, pattern):
+        self.bar_plist[n] = pattern
+        
 class CairoCanvas(Canvas):
     """This is a basic class that stores and draws on a Cairo surface,
     using various primitives related to drawing a real-time graph (up-arrows,
@@ -707,41 +778,45 @@ class CairoCanvas(Canvas):
         self._polyline_common(coor_list, color, thickness, do_snap)
         self.surface.ctx.fill()
 
-    def _draw_label_common(self, text, x, y, fopts, x_bearing_factor, \
-                           f_descent_factor, width_factor, f_height_factor, do_snap=True):
+    def _get_label_dim_common(self, text, x, y, fopts, x_bearing_factor, \
+                           f_descent_factor, width_factor, f_height_factor,
+                           scale, do_snap=True):
         """Helper function for drawing a label with some alignment. Instead of taking in an alignment,
         it takes in the scale factor for the font extent parameters, which give the raw data of how much to adjust
         the x and y parameters. Only should be used internally."""
-        x, y = self.scaled(x, y)
-        x, y = self.surface.get_real_coor(x, y)
-
-        self.surface.ctx.set_source_rgb(0.0, 0.0, 0.0)
-
-        self.surface.ctx.select_font_face(fopts.name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
-        self.surface.ctx.set_font_size(fopts.size * self.scale)
+        surface = None
+        if self.surface.ctx is None:
+            # surface lacks context of its own right now, so use temporary surface
+            # FIXME: possible bug here; the fonts are distorted (though they are invisible
+            # so it doesn't show up for us)
+            surface = self.surface.__class__()
+            surface.renew(10, 10)
+        else:
+            surface = self.surface
+                
+        surface.ctx.select_font_face(fopts.name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
+        surface.ctx.set_font_size(fopts.size * scale)
 
-        fe = self.surface.ctx.font_extents()
+        fe = surface.ctx.font_extents()
         f_ascent, f_descent, f_height = fe[:3]
 
-        te = self.surface.ctx.text_extents(text)
+        te = surface.ctx.text_extents(text)
         x_bearing, y_bearing, width, height = te[:4]
-
+        
         actual_x = x - x_bearing * x_bearing_factor - width * width_factor
         actual_y = y - f_descent * f_descent_factor + f_height * f_height_factor
 
-        self.surface.ctx.set_source_rgb(fopts.color[0], fopts.color[1], fopts.color[2])
-
         if do_snap:
-            self.surface.ctx.move_to(snap(actual_x), snap(actual_y))
-        else:
-            self.surface.ctx.move_to(actual_x, actual_y)
-
-        self.surface.ctx.show_text(text)
-
-    def draw_label(self, text, x, y, fopts=GraphFormat.DEF_FOPTS_LABEL, halign=AlignMode.LEFT, valign=AlignMode.BOTTOM, do_snap=True):
-        """Draws a label with the given parameters, with the given horizontal and vertical justification. One can override
-        the color from ``fopts'' by passing something in to ``pattern'', which overrides the color with an arbitrary
-        pattern."""
+            actual_x = snap(actual_x)
+            actual_y = snap(actual_y)
+        
+        return actual_x, actual_y, width, height, f_height
+
+    def get_label_dim(self, text, x, y, fopts=GraphFormat.DEF_FOPTS_LABEL, halign=AlignMode.LEFT,
+                      valign=AlignMode.BOTTOM, do_scale=True, do_snap=True):
+        """Gets the dimensions of the label if it were to be drawn with the given parameters, and with the given
+        justification. Note: this does everything except actually draw the label"""
+        
         x_bearing_factor, f_descent_factor, width_factor, f_height_factor = 0.0, 0.0, 0.0, 0.0
         halign_factors = {AlignMode.LEFT : (0.0, 0.0), AlignMode.CENTER : (1.0, 0.5), AlignMode.RIGHT : (1.0, 1.0)}
         if halign not in halign_factors:
@@ -752,9 +827,25 @@ class CairoCanvas(Canvas):
         if valign not in valign_factors:
             raise ValueError('Invalid alignment value')
         f_descent_factor, f_height_factor = valign_factors[valign]
-
-        self._draw_label_common(text, x, y, fopts, x_bearing_factor, \
-                f_descent_factor, width_factor, f_height_factor, do_snap)
+        
+        scale = 1.0
+        if do_scale:
+            scale = self.scale
+            
+        return self._get_label_dim_common(text, x, y, fopts, x_bearing_factor,
+                                          f_descent_factor, width_factor, f_height_factor,
+                                          scale, do_snap)
+        
+    def draw_label(self, text, x, y, fopts=GraphFormat.DEF_FOPTS_LABEL, halign=AlignMode.LEFT, valign=AlignMode.BOTTOM, do_snap=True):
+        """Draws a label with the given parameters, with the given horizontal and vertical justification."""
+        
+        x, y = self.scaled(x, y)
+        actual_x, actual_y, width, height, f_height = self.get_label_dim(text, x, y, fopts, halign, valign, True, do_snap)
+        actual_x, actual_y = self.surface.get_real_coor(actual_x, actual_y)
+        
+        self.surface.ctx.set_source_rgb(fopts.color[0], fopts.color[1], fopts.color[2])
+        self.surface.ctx.move_to(actual_x, actual_y)
+        self.surface.ctx.show_text(text)
 
     def draw_label_with_sscripts(self, text, supscript, subscript, x, y, \
                                  textfopts=GraphFormat.DEF_FOPTS_LABEL, sscriptfopts=GraphFormat.DEF_FOPTS_LABEL_SSCRIPT, \
@@ -782,9 +873,20 @@ class CairoCanvas(Canvas):
             ytmp = y + f_height / 4.0
             self.draw_label(subscript, xtmp, ytmp, sscriptfopts, halign, valign, do_snap)
 
+def snap(pos):
+    """Takes in an x- or y-coordinate ``pos'' and snaps it to the pixel grid.
+    This is necessary because integer coordinates in Cairo actually denote
+    the spaces between pixels, not the pixels themselves, so if we draw a
+    line of width 1 on integer coordinates, it will come out blurry unless we shift it,
+    since the line will get distributed over two pixels. We actually apply this to all
+    coordinates to make sure everything is aligned."""
+    return pos - 0.5
+    
 # represents a selectable region of the graph
 class SelectableRegion(object):
     def __init__(self, x, y, width, height, event):
+        """Sets up a region with the given dimensions and containing a
+        certain event."""
         self.x = x
         self.y = y
         self.width = width
@@ -793,15 +895,23 @@ class SelectableRegion(object):
         self.scale = 1.0
 
     def get_dimensions(self):
+        """Gets the dimensions of the region."""
         return (self.x, self.y, self.width, self.height)
 
     def get_event(self):
+        """Gets the event associated with the region."""
         return self.event
 
     def set_scale(self, scale):
         self.scale = scale
 
+    def is_dummy(self):
+        return self.x is None or self.y is None
+        
     def intersects(self, x, y, width, height):
+        if self.is_dummy():
+            return False
+            
         return x <= (self.x + self.width) * self.scale \
            and x + width >= self.x * self.scale \
            and y <= (self.y + self.height) * self.scale \
diff --git a/unit_trace/viz/format.py b/unit_trace/viz/format.py
index d3ed4fd..18dfd5a 100644
--- a/unit_trace/viz/format.py
+++ b/unit_trace/viz/format.py
@@ -37,6 +37,8 @@ class GraphFormat(object):
     X_AXIS_MEASURE_OFS = 30
     X_AXIS_LABEL_GAP = 10
     Y_AXIS_ITEM_GAP = 10
+    TOP_ITEM_VERT_GAP = 20
+    TOP_ITEM_HORIZ_GAP = 20
     MAJ_TICK_SIZE = 20
     MIN_TICK_SIZE = 12
 
diff --git a/unit_trace/viz/graph.py b/unit_trace/viz/graph.py
index a10d9bd..fa0df99 100644
--- a/unit_trace/viz/graph.py
+++ b/unit_trace/viz/graph.py
@@ -14,7 +14,7 @@ class Graph(object):
     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(),
+    def __init__(self, CanvasType, surface, start_time, end_time, y_item_list, top_item_list, attrs=GraphFormat(),
                  item_clist=DEF_ITEM_CLIST, bar_plist=DEF_BAR_PLIST):
         # deal with possibly blank schedules
         if start_time is None:
@@ -29,6 +29,7 @@ class Graph(object):
         self.start_time = start_time
         self.end_time = end_time
         self.y_item_list = y_item_list
+        self.top_item_list = top_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
@@ -59,11 +60,25 @@ class Graph(object):
 
         #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)
+        
+        # item clist might end before 
+        full_item_clist = []
+        full_bar_plist = []
+        
+        for i in range(0, len(self.y_item_list)):
+            full_item_clist.append(item_clist[i % len(item_clist)])
+        
+        for i in range(0, len(self.top_item_list)):
+            full_bar_plist.append(bar_plist[i % (len(bar_plist) - 1)])
+            
+        # last bar pattern is a ``special pattern'' so put it at
+        # the end (and nowhere else)    
+        full_bar_plist.append(bar_plist[-1])
+        
+        self.canvas = CanvasType(width, height, full_item_clist, full_bar_plist, surface)
+
+    def get_intersecting_regions(self, real_x, real_y, width, height):
+        return self.canvas.get_intersecting_regions(real_x, real_y, width, height)
 
     def get_width(self):
         return self.width
@@ -86,12 +101,31 @@ class Graph(object):
     def has_sel_region(self, event):
         return self.canvas.has_sel_region(event)
 
+    def get_item_color(self, no):
+        return self.canvas.get_item_color(no)
+        
+    def get_bar_pattern(self, no):
+        return self.canvas.get_bar_pattern(no)
+    
+    def set_bar_pattern(self, no, pattern):
+        self.canvas.set_bar_pattern(no, pattern)
+        
     def update_view(self, x, y, width, height, scale, ctx):
-        """Proxy into the surface's pan."""
+        """Updates the view's window location, scale factor, and Cairo context (i.e. where
+        the view currently ``is'')."""
         self.canvas.surface.pan(x, y, width, height)
         self.canvas.set_scale(scale)
         self.canvas.surface.change_ctx(ctx)
 
+    def set_tmp_surface(self, surface):
+        """Changes to a temporary surface, instead of using the default surface (the
+        surface that writes to the screen."""
+        self.canvas.set_tmp_surface(surface)
+    
+    def revert_surface(self):
+        """Changes back to the default surface."""
+        self.canvas.revert_surface()
+        
     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
@@ -158,24 +192,61 @@ class Graph(object):
     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()
+        self.draw_y_axis()
+
+    def render_all(self, sched):
+        """Renders an entire schedule onto the surface."""
+        self.canvas.whiteout()
+        start, end = sched.get_time_bounds()
+        self.draw_skeleton(start, end, 0, len(self.y_item_list))
+        
+        slots = {}
+        all_events = {}
+        sched.get_time_slot_array().get_slots(slots,
+                        start, end, 0, len(sched.get_task_list()),
+                        self.list_type)
+        for event in sched.get_time_slot_array().get_events(slots, self.list_type,
+                schedule.EVENT_LIST):
+            if event.get_layer() not in all_events:
+                all_events[event.get_layer()] = {}
+            all_events[event.get_layer()][event] = None
+                    
+        self.render_events(all_events)
 
-    def render_surface(self, sched, regions, selectable=False):
-        raise NotImplementedError
+    def get_events_to_render(self, sched, regions, selectable=False):
+        slots = {}
 
-    def render_all(self, schedule):
-        raise NotImplementedError
+        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,
+                        self.list_type)
+        
+        events_to_render = {}
+        for layer in Canvas.LAYERS:
+            events_to_render[layer] = {}
+        
+        for event in sched.get_time_slot_array().get_events(slots,
+                self.list_type, schedule.EVENT_LIST):
+            events_to_render[event.get_layer()][event] = None
 
-    def get_events_to_render(self, sched, regions, selectable=False):
-        raise NotImplementedError
+        return events_to_render
 
     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)
-
+        events = self.get_events_to_render(sched, regions, selectable)
+        if not selectable:
+            self.draw_skeleton(self.min_time, self.max_time,
+                               self.min_item, self.max_item)
+        self.render_events(events, selectable)
+                               
     def render_events(self, events, selectable=False):
         for layer in Canvas.LAYERS:
             prev_events = {}
@@ -207,7 +278,7 @@ class Graph(object):
         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))
@@ -219,11 +290,51 @@ class Graph(object):
                                 self.start_time + start_tick * self.attrs.time_per_maj,
                                 self.attrs.time_per_maj, False)
 
-    def draw_y_axis_with_labels(self):
+    def draw_y_axis(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)
-
+        #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_y_axis_item(self, item_no, selected):
+        self.canvas.draw_y_axis_item(self.origin[0], self.origin[1], self._get_y_axis_height(),
+                                        self.y_item_list[item_no], item_no, self.attrs.y_item_size,
+                                        selected)
+    
+    def add_sel_y_axis_item(self, item_no, event):
+        self.canvas.add_sel_y_axis_item(self.origin[0], self.origin[1], self._get_y_axis_height(),
+                                        self.y_item_list[item_no], item_no, self.attrs.y_item_size,
+                                        event)
+    
+    def draw_top_item(self, item_no, selected):
+        self.canvas.draw_top_item(self.origin[0], self.origin[1], self._get_y_axis_height(),
+                                        self.top_item_list[item_no], item_no, self.top_item_list[0:item_no],
+                                        selected)
+    
+    def add_sel_top_item(self, item_no, event):
+        self.canvas.add_sel_top_item(self.origin[0], self.origin[1], self._get_y_axis_height(),
+                                        self.top_item_list[item_no], item_no, self.top_item_list[0:item_no],
+                                        event)
+                                        
+    def all_one_item_selected(self, selected):
+        """When the user selects some parts of the graph, it might be the case that all of the
+        parts lie under one ``item'' of the graph. In this case, certain operations are likely
+        possible when parts under different items are selected. So this method tells us whether
+        a set of selected items satisfies this criterion. It also gives the item selected if
+        so."""
+        raise NotImplementedError
+        
+    def draw_cpu_item(self, item_no, selected):
+        raise NotImplementedError
+        
+    def add_sel_cpu_item(self, item_no, event):
+        raise NotImplementedError
+        
+    def draw_task_item(self, item_no, selected):
+        raise NotImplementedError
+        
+    def add_sel_task_item(self, item_no, event):
+        raise NotImplementedError
+            
     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
@@ -288,35 +399,36 @@ class Graph(object):
         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 __init__(self, CanvasType, surface, start_time, end_time, y_item_list, top_item_list, attrs=GraphFormat(),
+                 item_clist=Graph.DEF_ITEM_CLIST, bar_plist=Graph.DEF_BAR_PLIST):
+        super(TaskGraph, self).__init__(CanvasType, surface, start_time, end_time, y_item_list, top_item_list,
+                                        attrs, item_clist, bar_plist)
+        self.list_type = schedule.TimeSlotArray.TASK_LIST
+        
+    def all_one_item_selected(self, selected):
+        cpu = None
+        for layer in selected:
+            for event in selected[layer]:
+                if cpu is None:
+                    cpu = event.get_cpu()
+                else:
+                    if event.get_cpu() is None or event.get_cpu() != cpu:
+                        return None
+                        
+        return cpu
+        
+    def draw_cpu_item(self, item_no, selected):
+        self.draw_top_item(item_no, selected)
+        
+    def add_sel_cpu_item(self, item_no, event):
+        self.add_sel_top_item(item_no, event)
+        
+    def draw_task_item(self, item_no, selected):
+        self.draw_y_axis_item(item_no, selected)
+        
+    def add_sel_task_item(self, item_no, event):
+        self.add_sel_y_axis_item(item_no, event)
+        
     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)
@@ -446,71 +558,36 @@ class TaskGraph(Graph):
         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 __init__(self, CanvasType, surface, start_time, end_time, y_item_list, top_item_list, attrs=GraphFormat(),
+                 item_clist=Graph.DEF_ITEM_CLIST, bar_plist=Graph.DEF_BAR_PLIST):
+        super(CpuGraph, self).__init__(CanvasType, surface, start_time, end_time, y_item_list, top_item_list,
+                                        attrs, item_clist, bar_plist)
+        self.list_type = schedule.TimeSlotArray.CPU_LIST
+        
+    def all_one_item_selected(self, selected):
+        task_no = None
+        for layer in selected:
+            for event in selected[layer]:
+                if task_no is None and event.get_task() is not None:
+                    task_no = event.get_task().get_task_no()
+                else:
+                    if event.get_task() is None or event.get_task().get_task_no() != task_no:
+                        return None
+                        
+        return task_no
+            
+    def draw_cpu_item(self, item_no, selected):
+        self.draw_y_axis_item(item_no, selected)
+        
+    def add_sel_cpu_item(self, item_no, event):
+        self.add_sel_y_axis_item(item_no, event)
+        
+    def draw_task_item(self, item_no, selected):
+        self.draw_top_item(item_no, selected)
+        
+    def add_sel_task_item(self, item_no, event):
+        self.add_sel_top_item(item_no, event)
+        
     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)
diff --git a/unit_trace/viz/renderer.py b/unit_trace/viz/renderer.py
index 056e1a5..1970b8a 100644
--- a/unit_trace/viz/renderer.py
+++ b/unit_trace/viz/renderer.py
@@ -12,13 +12,15 @@ class Renderer(object):
     def prepare_task_graph(self, SurfaceType=ImageSurface, attrs=GraphFormat()):
         """Outputs the fully-rendered graph (y-axis = tasks) to a Cairo ImageSurface"""
         item_list = self.get_task_item_list()
+        top_list = ['CPU %d' % i for i in range(0, self.schedule.get_num_cpus())]
         start, end = self.schedule.get_time_bounds()
-        self.graph = TaskGraph(CairoCanvas, SurfaceType(), start, end, item_list, attrs)
+        self.graph = TaskGraph(CairoCanvas, SurfaceType(), start, end, item_list, top_list, attrs)
 
     def prepare_cpu_graph(self, SurfaceType=ImageSurface, attrs=GraphFormat()):
         item_list = ['CPU %d' % i for i in range(0, self.schedule.get_num_cpus())]
+        top_list = self.get_task_item_list()
         start, end = self.schedule.get_time_bounds()
-        self.graph = CpuGraph(CairoCanvas, SurfaceType(), start, end, item_list, attrs)
+        self.graph = CpuGraph(CairoCanvas, SurfaceType(), start, end, item_list, top_list, attrs)
 
     def render_graph_full(self):
         """Does the heavy lifting for rendering a task or CPU graph, by scanning the schedule
diff --git a/unit_trace/viz/schedule.py b/unit_trace/viz/schedule.py
index a44ce8d..82b7ea1 100644
--- a/unit_trace/viz/schedule.py
+++ b/unit_trace/viz/schedule.py
@@ -21,82 +21,106 @@ class TimeSlotArray(object):
 
     TASK_LIST = 0
     CPU_LIST = 1
-
+    LIST_TYPES = (TASK_LIST, CPU_LIST)
+    
+    PRE_ITEM_NO = -1
+    POST_ITEM_NO = -2
+    
+    PRE_SLOT = 'pre'
+    POST_SLOT = 'post'
+    ALL_SLOT = 'all'
+    
     def __init__(self, time_per_maj=None, num_tasks=0, num_cpus=0):
         if time_per_maj is None:
             self.array = None
             return
 
         self.time_per_maj = time_per_maj
-        self.list_sizes = { TimeSlotArray.TASK_LIST : num_tasks, TimeSlotArray.CPU_LIST : num_cpus }
+        self.list_sizes = { TimeSlotArray.TASK_LIST : num_tasks, TimeSlotArray.CPU_LIST : num_cpus}
         self.array = {}
-
+        self.min_slot = None
+        self.max_slot = None
+        
         for type in self.list_sizes:
             num = self.list_sizes[type]
             self.array[type] = []
-            for j in range(0, num):
+            for i in range(0, num + 2): # two more for pre and post
                 # for each slot in the array, we need a list of all events under this type
                 # (for example, a list of all events that occur in this time slot, indexed
                 # by task).
-                self.array[type].append(dict(zip(EVENT_LIST, \
+                self.array[type].append(dict(zip(EVENT_LIST,
                                 [{} for j in range(0, len(EVENT_LIST))])))
 
     def get_time_slot(self, time):
         return int(time // self.time_per_maj)
-
-    def _put_event_in_slot(self, list_type, no, klass, slot, event):
+        
+    def put_event_in_slot(self, list_type, no, klass, slot, event):
         if slot not in self.array[list_type][no][klass]:
             self.array[list_type][no][klass][slot] = []
         self.array[list_type][no][klass][slot].append(event)
+        
+        if self.min_slot is None or slot < self.min_slot:
+            self.min_slot = slot
+        if self.max_slot is None or slot > self.max_slot:
+            self.max_slot = slot
 
-    def add_event_to_time_slot(self, event):
+    def add_event_to_time_slot(self, event, item_nos):
         task_no = event.get_job().get_task().get_task_no()
         cpu = event.get_cpu()
-        time_slot = self.get_time_slot(event.get_time())
 
-        self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, event.__class__, time_slot, event)
-        self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, event.__class__, time_slot, event)
+        slot = self.get_time_slot(event.get_time())
+        
+        for type in item_nos:
+            self.put_event_in_slot(type, item_nos[type], event.__class__, slot, event)
+    
+    def fill_span_event_from_start(self, event, item_nos):
+        end_slot = None
+        if event.corresp_end_event is None:
+            end_slot = self.get_time_slot(event.get_schedule().end) + 1
+        else:
+            end_slot = self.get_time_slot(event.corresp_end_event.get_time())
+        start_slot = self.get_time_slot(event.get_time())
 
-        if event.__class__ in SPAN_END_EVENTS:
-            self.fill_span_event_from_end(event)
+        for slot in range(start_slot + 1, end_slot):
+            dummy = event.dummy_class()
+            dummy.corresp_start_event = event
+            dummy.corresp_end_event = event.corresp_end_event
+
+            for type in item_nos:
+                self.put_event_in_slot(type, item_nos[type], event.dummy_class, slot, dummy)
 
-    def fill_span_event_from_end(self, event):
+    def fill_span_event_from_end(self, event, item_nos):
         start_slot = None
         if event.corresp_start_event is None:
-            start_slot = self.get_time_slot(event.get_job().get_task().get_schedule().start) - 1
+            start_slot = self.get_time_slot(event.get_schedule().start) - 1
         else:
             start_slot = self.get_time_slot(event.corresp_start_event.get_time())
         end_slot = self.get_time_slot(event.get_time())
 
         for slot in range(start_slot + 1, end_slot):
-            task_no = event.get_job().get_task().get_task_no()
-            cpu = event.get_cpu()
-
-            dummy = SPAN_END_EVENTS[event.__class__](task_no, cpu)
+            dummy = event.dummy_class()
             dummy.corresp_start_event = event.corresp_start_event
             dummy.corresp_end_event = event
 
-            self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, dummy.__class__, slot, dummy)
-            self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, dummy.__class__, slot, dummy)
-
-    def fill_span_event_from_start(self, event):
-        end_slot = None
-        if event.corresp_end_event is None:
-            end_slot = self.get_time_slot(event.get_job().get_task().get_schedule().end) + 1
-        else:
-            end_slot = self.get_time_slot(event.corresp_end_event.get_time())
-        start_slot = self.get_time_slot(event.get_time())
-
-        for slot in range(start_slot + 1, end_slot):
-            task_no = event.get_job().get_task().get_task_no()
-            cpu = event.get_cpu()
-
-            dummy = SPAN_START_EVENTS[event.__class__](task_no, cpu)
-            dummy.corresp_start_event = event
-            dummy.corresp_end_event = event.corresp_end_event
-
-            self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, dummy.__class__, slot, dummy)
-            self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, dummy.__class__, slot, dummy)
+            for type in item_nos:
+                self.put_event_in_slot(type, item_nos[type], event.dummy_class, slot, dummy)
+                        
+    def add_item_dummies(self, sched):
+        start = sched.get_time_bounds()[0]
+        
+        for task in sched.get_tasks().values():
+            dummy = TaskDummy(start, task)
+            self.put_event_in_slot(TimeSlotArray.TASK_LIST, task.get_task_no(), dummy.__class__,
+                                        TimeSlotArray.PRE_SLOT, dummy)
+            self.put_event_in_slot(TimeSlotArray.CPU_LIST, TimeSlotArray.PRE_ITEM_NO, dummy.__class__,
+                                        TimeSlotArray.ALL_SLOT, dummy)
+                                        
+        for i in range(0, self.list_sizes[TimeSlotArray.CPU_LIST]):
+            dummy = CPUDummy(start, sched, i)
+            self.put_event_in_slot(TimeSlotArray.CPU_LIST, i, dummy.__class__,
+                                    TimeSlotArray.PRE_SLOT, dummy)
+            self.put_event_in_slot(TimeSlotArray.TASK_LIST, TimeSlotArray.PRE_ITEM_NO, dummy.__class__,
+                                        TimeSlotArray.ALL_SLOT, dummy)
 
     def get_events(self, slots, list_type, event_types):
         for type in event_types:
@@ -107,25 +131,44 @@ class TimeSlotArray(object):
                             yield event
 
     def get_slots(self, slots, start, end, start_no, end_no, list_type):
-        if self.array is None:
-            return # empty schedule
-
         if start > end:
             raise ValueError('Litmus is not a time machine')
         if start_no > end_no:
             raise ValueError('start no should be less than end no')
-
+    
+        if self.min_slot is None:
+            # no events ever got added
+            return {}
+            
         start_slot = self.get_time_slot(start)
         end_slot = self.get_time_slot(end) + 1
+        
+        item_no_list = []
+        if start_no < 0:
+            item_no_list.append(TimeSlotArray.PRE_ITEM_NO)
+        if end_no >= self.list_sizes[list_type]:
+            item_no_list.append(TimeSlotArray.POST_ITEM_NO)
         start_no = max(0, start_no)
         end_no = min(self.list_sizes[list_type] - 1, end_no)
-
+        item_no_list += range(start_no, end_no + 1)
+        
+        edge_slots = [TimeSlotArray.ALL_SLOT]
+        if start_slot <= self.min_slot:
+            edge_slots.append(TimeSlotArray.PRE_SLOT)
+        if end_slot >= self.max_slot:
+            edge_slots.append(TimeSlotArray.POST_SLOT)
+        
+        for slot in edge_slots:
+            slots[slot] = {}
+            for no in item_no_list:
+                slots[slot][no] = None
+        
         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):
+            for no in item_no_list:
                 slots[slot][no] = None
-
+                
 class Schedule(object):
     """The total schedule (task system), consisting of a certain number of
     tasks."""
@@ -203,11 +246,14 @@ class Schedule(object):
             # the range of whatever we read in. So we need to fill dummies starting from the initial
             # event all the way to the end of the graph, so that the renderer can see the event no matter
             # how far the user scrolls to the right.
-            for span_event in SPAN_START_EVENTS:
-                event = switches[span_event]
-                if event is not None:
-                    self.time_slot_array.fill_span_event_from_start(event)
-
+            for event in EVENT_LIST:
+                switch_event = switches[event]
+                if switch_event is not None:
+                    event.fill_span_event_from_start()
+    
+        # add events that correspond to the tasks and CPUS, at the very beginning
+        self.time_slot_array.add_item_dummies(self)
+        
     def add_task(self, task):
         if task.name in self.tasks:
             raise ValueError("task already in list!")
@@ -311,12 +357,23 @@ class DummyEvent(object):
     def get_cpu(self):
         return self.cpu
 
+    def get_schedule(self):
+        return self.get_task().get_schedule()
+    
+    def get_task(self):
+        return self.get_job().get_task()
+            
     def get_job(self):
         return self.job
 
     def get_layer(self):
         return self.layer
-
+    
+    def is_selected(self):
+        """Returns whether the event has been selected by the user. (needed for rendering)"""
+        selected = self.get_schedule().get_selected()
+        return self.get_layer() in selected and self in selected[self.get_layer()]
+        
     def render(self, graph, layer, prev_events, selectable=False):
         """Method that the visualizer calls to tell the event to render itself
         Obviously only implemented by subclasses (actual event types)
@@ -363,12 +420,7 @@ class Event(DummyEvent):
         us how we should render the event."""
         return self.erroneous
 
-    def is_selected(self):
-        """Returns whether the event has been selected by the user. (needed for rendering)"""
-        selected = self.get_job().get_task().get_schedule().get_selected()
-        return self.get_layer() in selected and self in selected[self.get_layer()]
-
-    def scan(self, cur_cpu, switches):
+    def scan(self, cur_cpu, switches, item_nos=None):
         """Part of the procedure that walks through all the events and sets
         some parameters that are unknown at first. For instance, a SwitchAwayEvent
         should know when the previous corresponding SwitchToEvent occurred, but
@@ -377,17 +429,86 @@ class Event(DummyEvent):
         time in the scan, and ``switches'' gives the last time a certain switch
         (e.g. SwitchToEvent, InversionStartEvent) occurred"""
         time = self.get_time()
-        sched = self.get_job().get_task().get_schedule()
+        sched = self.get_schedule()
         if sched.start is None or time < sched.start:
             sched.start = time
         if sched.end is None or time > sched.end:
             sched.end = time
 
-        sched.get_time_slot_array().add_event_to_time_slot(self)
-
-class ErrorEvent(Event):
-    pass
-
+        if item_nos is None:
+            item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
+                         TimeSlotArray.CPU_LIST : self.get_cpu() }
+        sched.get_time_slot_array().add_event_to_time_slot(self, item_nos)
+        self.fill_span_event_from_end()
+    
+    def fill_span_event_from_start(self):
+        """This method exists for events that can ``range'' over a period of time
+        (e.g. SwitchAway and SwitchTo). In case a start event is not paired with
+        an end event, or vice versa, we want to fill in dummy events to range all
+        the way to the beginning or end. Since most events occur only at a specific
+        time, this is usually a no-op."""
+        pass
+        
+    def fill_span_event_from_end(self):
+        """The mirror image of the last method."""
+        pass
+        
+class SpanEvent(Event):
+    def __init__(self, time, cpu, dummy_class):
+        super(SpanEvent, self).__init__(time, cpu)
+        self.dummy_class = dummy_class
+
+class SpanDummy(DummyEvent):
+    def __init__(self):
+        super(SpanDummy, self).__init__(None, None)
+    
+    def get_task(self):
+        if self.corresp_start_event is not None:
+            return self.corresp_start_event.get_task()
+        if self.corresp_end_event is not None:
+            return self.corresp_end_event.get_task()
+        return None
+        
+    def get_schedule(self):
+        if self.corresp_start_event is not None:
+            return self.corresp_start_event.get_schedule()
+        if self.corresp_end_event is not None:
+            return self.corresp_end_event.get_schedule()
+        return None
+    
+    def get_job(self):
+        if self.corresp_start_event is not None:
+            return self.corresp_start_event.get_job()
+        if self.corresp_end_event is not None:
+            return self.corresp_end_event.get_job()
+        return None
+    
+    def get_cpu(self):
+        if self.corresp_start_event is not None:
+            return self.corresp_start_event.get_cpu()
+        if self.corresp_end_event is not None:
+            return self.corresp_end_event.get_cpu()
+        return None
+        
+    def get_time(self):
+        if self.corresp_start_event is not None:
+            return self.corresp_start_event.get_time()
+        if self.corresp_end_event is not None:
+            return self.corresp_end_event.get_time()
+        return None
+            
+class StartSpanEvent(SpanEvent):
+    def fill_span_event_from_start(self):
+        item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
+                     TimeSlotArray.CPU_LIST : self.get_cpu() }
+        self.get_schedule().get_time_slot_array().fill_span_event_from_start(self, item_nos)
+
+class EndSpanEvent(SpanEvent):
+    def fill_span_event_from_end(self):
+        item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
+                     TimeSlotArray.CPU_LIST : self.get_cpu() }
+        self.get_schedule().get_time_slot_array().fill_span_event_from_end(self, item_nos)
+                
 class SuspendEvent(Event):
     def __init__(self, time, cpu):
         super(SuspendEvent, self).__init__(time, cpu)
@@ -459,9 +580,9 @@ class CompleteEvent(Event):
                 graph.draw_completion_marker_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                                  self.get_cpu(), self.is_selected())
 
-class SwitchToEvent(Event):
+class SwitchToEvent(StartSpanEvent):
     def __init__(self, time, cpu):
-        super(SwitchToEvent, self).__init__(time, cpu)
+        super(SwitchToEvent, self).__init__(time, cpu, IsRunningDummy)
         self.layer = Canvas.BOTTOM_LAYER
         self.corresp_end_event = None
 
@@ -523,9 +644,9 @@ class SwitchToEvent(Event):
                                    task_no, cpu, self.get_job().get_job_no(),
                                    clip, self.is_selected())
 
-class SwitchAwayEvent(Event):
+class SwitchAwayEvent(EndSpanEvent):
     def __init__(self, time, cpu):
-        super(SwitchAwayEvent, self).__init__(time, cpu)
+        super(SwitchAwayEvent, self).__init__(time, cpu, IsRunningDummy)
         self.layer = Canvas.BOTTOM_LAYER
         self.corresp_start_event = None
 
@@ -600,7 +721,9 @@ class ReleaseEvent(Event):
         return 'Release'
 
     def scan(self, cur_cpu, switches):
-        super(ReleaseEvent, self).scan(cur_cpu, switches)
+        item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
+                     TimeSlotArray.CPU_LIST : TimeSlotArray.POST_ITEM_NO }
+        super(ReleaseEvent, self).scan(cur_cpu, switches, item_nos)
 
     def render(self, graph, layer, prev_events, selectable=False):
         prev_events[self] = None
@@ -622,7 +745,9 @@ class DeadlineEvent(Event):
         return 'Deadline'
 
     def scan(self, cur_cpu, switches):
-        super(DeadlineEvent, self).scan(cur_cpu, switches)
+        item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
+                     TimeSlotArray.CPU_LIST : TimeSlotArray.POST_ITEM_NO }
+        super(DeadlineEvent, self).scan(cur_cpu, switches, item_nos)
 
     def render(self, graph, layer, prev_events, selectable=False):
         prev_events[self] = None
@@ -635,9 +760,9 @@ class DeadlineEvent(Event):
                                               self.get_job().get_job_no(), self.is_selected())
 
 
-class InversionStartEvent(ErrorEvent):
+class InversionStartEvent(StartSpanEvent):
     def __init__(self, time):
-        super(InversionStartEvent, self).__init__(time, Event.NO_CPU)
+        super(InversionStartEvent, self).__init__(time, Event.NO_CPU, InversionDummy)
         self.layer = Canvas.BOTTOM_LAYER
         self.corresp_end_event = None
 
@@ -665,13 +790,20 @@ class InversionStartEvent(ErrorEvent):
                 '\nCPU: ' + str(self.get_cpu()) + \
                 '\nStart: ' + str(self.get_time()) + \
                 '\nEnd: ' + str(self.corresp_end_event.get_time())
-
+    
+    def fill_span_event_from_start(self):
+        item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
+                     TimeSlotArray.CPU_LIST : TimeSlotArray.POST_ITEM_NO }
+        self.get_schedule().get_time_slot_array().fill_span_event_from_start(self, item_nos)
+        
     def scan(self, cur_cpu, switches):
         switches[InversionStartEvent] = self
         self.corresp_end_event = None
 
         # the corresp_end_event should already be set
-        super(InversionStartEvent, self).scan(cur_cpu, switches)
+        item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
+                     TimeSlotArray.CPU_LIST : TimeSlotArray.POST_ITEM_NO }
+        super(InversionStartEvent, self).scan(cur_cpu, switches, item_nos)
 
     def render(self, graph, layer, prev_events, selectable=False):
         if layer == self.layer:
@@ -696,9 +828,9 @@ class InversionStartEvent(ErrorEvent):
                                      clip, self.is_selected())
 
 
-class InversionEndEvent(ErrorEvent):
+class InversionEndEvent(EndSpanEvent):
     def __init__(self, time):
-        super(InversionEndEvent, self).__init__(time, Event.NO_CPU)
+        super(InversionEndEvent, self).__init__(time, Event.NO_CPU, InversionDummy)
         self.layer = Canvas.BOTTOM_LAYER
         self.corresp_start_event = None
 
@@ -720,6 +852,11 @@ class InversionEndEvent(ErrorEvent):
 
         return self.corresp_start_event.str_long()
 
+    def fill_span_event_from_end(self):
+        item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
+                     TimeSlotArray.CPU_LIST : TimeSlotArray.POST_ITEM_NO }
+        self.get_schedule().get_time_slot_array().fill_span_event_from_end(self, item_nos)
+        
     def scan(self, cur_cpu, switches):
         self.corresp_start_event = switches[InversionStartEvent]
 
@@ -733,7 +870,9 @@ class InversionEndEvent(ErrorEvent):
             self.erroneous = True
             #print "inversion end was not matched by a corresponding inversion start"
 
-        super(InversionEndEvent, self).scan(cur_cpu, switches)
+        item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
+                     TimeSlotArray.CPU_LIST : TimeSlotArray.POST_ITEM_NO }
+        super(InversionEndEvent, self).scan(cur_cpu, switches, item_nos)
 
     def render(self, graph, layer, prev_events, selectable=False):
         if self.corresp_start_event is None:
@@ -757,9 +896,9 @@ class InversionEndEvent(ErrorEvent):
                 return # already rendered the bar
             self.corresp_start_event.render(graph, layer, prev_events, selectable)
 
-class InversionDummy(DummyEvent):
-    def __init__(self, time, cpu):
-        super(InversionDummy, self).__init__(time, Event.NO_CPU)
+class InversionDummy(SpanDummy):
+    def __init__(self):
+        super(InversionDummy, self).__init__()
         self.layer = Canvas.BOTTOM_LAYER
 
     def render(self, graph, layer, prev_events, selectable=False):
@@ -772,9 +911,9 @@ class InversionDummy(DummyEvent):
                 return # we have already been rendered
             self.corresp_start_event.render(graph, layer, prev_events, selectable)
 
-class IsRunningDummy(DummyEvent):
-    def __init__(self, time, cpu):
-        super(IsRunningDummy, self).__init__(time, Event.NO_CPU)
+class IsRunningDummy(SpanDummy):
+    def __init__(self):
+        super(IsRunningDummy, self).__init__()
         self.layer = Canvas.BOTTOM_LAYER
 
     def render(self, graph, layer, prev_events, selectable=False):
@@ -787,11 +926,66 @@ class IsRunningDummy(DummyEvent):
                 return # we have already been rendered
             self.corresp_start_event.render(graph, layer, prev_events, selectable)
 
+class TaskDummy(DummyEvent):
+    """A dummy event that represents an entire task. Used for rendering the task's name."""
+    def __init__(self, time, task):
+        super(TaskDummy, self).__init__(time, None)
+        self.task = task
+        self.layer = Canvas.BOTTOM_LAYER
+        
+    def get_name(self):
+        return 'Task'
+        
+    def __str__(self):
+        return 'Task ' + self.task.get_name()
+
+    def str_long(self):
+        return 'Task ' + self.task.get_name()
+    
+    def get_task(self):
+        return self.task
+                        
+    def render(self, graph, layer, prev_events, selectable=False):
+        if selectable:
+            graph.add_sel_task_item(self.task.get_task_no(), self)
+        else:
+            graph.draw_task_item(self.task.get_task_no(), self.is_selected())
+    
+class CPUDummy(DummyEvent):
+    """A dummy event that represents a certain CPU. Used for rendering the CPU's ``name''
+    (i.e. ``CPU #n'')"""
+    def __init__(self, time, sched, cpu):
+        super(CPUDummy, self).__init__(time, cpu)
+        self.sched = sched
+        self.layer = Canvas.BOTTOM_LAYER
+        
+    def get_name(self):
+        return 'CPU'
+        
+    def __str__(self):
+        return 'CPU #' + str(self.get_cpu())
+
+    def str_long(self):
+        return 'CPU #' + str(self.get_cpu())
+    
+    def get_task(self):
+        return None
+        
+    def get_schedule(self):
+        # we don't have a job, so get the schedule from the schedule passed in
+        return self.sched
+            
+    def render(self, graph, layer, prev_events, selectable=False):
+        if selectable:
+            graph.add_sel_cpu_item(self.cpu, self)
+        else:
+            graph.draw_cpu_item(self.cpu, self.is_selected())
+            
 EVENT_LIST = {SuspendEvent : None, ResumeEvent : None, CompleteEvent : None,
               SwitchAwayEvent : None, SwitchToEvent : None, ReleaseEvent : None,
               DeadlineEvent : None, IsRunningDummy : None,
               InversionStartEvent : None, InversionEndEvent : None,
-              InversionDummy : None}
+              InversionDummy : None, TaskDummy : None, CPUDummy : None}
 
 SPAN_START_EVENTS = { SwitchToEvent : IsRunningDummy, InversionStartEvent : InversionDummy }
 SPAN_END_EVENTS = { SwitchAwayEvent : IsRunningDummy, InversionEndEvent : InversionDummy}
diff --git a/unit_trace/viz/viewer.py b/unit_trace/viz/viewer.py
index 5e707b8..33c84ff 100644
--- a/unit_trace/viz/viewer.py
+++ b/unit_trace/viz/viewer.py
@@ -4,7 +4,10 @@
 
 from schedule import *
 from renderer import *
+from graph import *
+from canvas import *
 from windows import *
+from format import *
 
 import pygtk
 import gtk
@@ -79,6 +82,23 @@ class GraphArea(gtk.DrawingArea):
         self.connect('button-release-event', self.button_release)
         self.connect('motion-notify-event', self.motion_notify)
 
+    def output_to_file(self, filename, ftype):
+        """Outputs the entire graph to a file."""
+        graph = self.renderer.get_graph()
+        surface = None
+        if ftype == 'png':
+            surface = ImageSurface()
+        elif ftype == 'svg':
+            surface = SVGSurface()
+        else:
+            raise ValueError
+            
+        surface.renew(graph.get_width(), graph.get_height())
+        graph.set_tmp_surface(surface)
+        graph.render_all(self.renderer.get_schedule())
+        surface.write_out(filename)
+        graph.revert_surface()
+        
     def expose(self, widget, expose_event, data=None):
         ctx = widget.window.cairo_create()
         graph = self.renderer.get_graph()
@@ -204,7 +224,11 @@ class GraphArea(gtk.DrawingArea):
                                 graph.get_attrs().y_item_size * GraphArea.VERT_PAGE_SCROLL_FACTOR / scale,
                                 self.height / scale)
             self.set_vvalue(vvalue)
-            
+    
+    def refresh_all(self):
+        """Refreshes the entire visible screen."""
+        self._dirty(0, 0, self.width, 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
@@ -216,7 +240,7 @@ class GraphArea(gtk.DrawingArea):
         refreshes the drawing of the graph that requested the change."""
         if self is not sender:
             self.renderer.get_graph().render_events(new, True)
-
+        
         self._tag_events(new)
 
         if self is sender:
@@ -228,20 +252,23 @@ class GraphArea(gtk.DrawingArea):
             else:
                 self.renderer.get_schedule().remove_selected(old)
                 self.renderer.get_schedule().add_selected(new)
+                
+            self.emit('update-sel-changes', self.renderer.get_schedule().get_selected())
 
     def _find_max_layer(self, regions):
-        max_layer = Canvas.BOTTOM_LAYER
-        for event in regions:
-            if event.get_layer() > max_layer:
-                max_layer = event.get_layer()
+        max_layer = -1
+        for layer in regions:
+            if layer > max_layer:
+                max_layer = layer
         return max_layer
 
     def _dirty_events(self, events):
         # if an event changed selected status, update the bounding area
         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,
+                if not events[layer][event][self].is_dummy():
+                    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,
@@ -284,15 +311,14 @@ 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)
+        just_selected = graph.get_intersecting_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
         else:
             max_layer = self._find_max_layer(just_selected)
-
-            for event in just_selected:
+            for event in just_selected[max_layer]:
                 if event.get_layer() == max_layer:
                     the_event = event
                     break
@@ -331,9 +357,11 @@ class GraphArea(gtk.DrawingArea):
             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)
+                i_regs = graph.get_intersecting_regions(rx, ry, rwidth, rheight)
+                for layer in i_regs:
+                    for event in i_regs[layer]:
+                        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)
@@ -344,8 +372,10 @@ class GraphArea(gtk.DrawingArea):
             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)
+                i_regs = graph.get_intersecting_regions(rx, ry, rwidth, rheight)
+                for layer in i_regs:
+                    for event in i_regs[layer]:
+                        self._select_event(add_selected, event)
 
             self.band_rect = x, y, width, height
             self.emit('request-refresh-events', self, add_selected, remove_selected, False)
@@ -362,9 +392,9 @@ class GraphArea(gtk.DrawingArea):
             self.left_button_start_coor = (button_event.x, button_event.y)
             graph.render_surface(self.renderer.get_schedule(), \
                                  [(button_event.x, button_event.y, 0, 0)], True)
-
-            just_selected = graph.get_selected_regions(button_event.x, button_event.y, 0, 0)
-
+            
+            just_selected = graph.get_intersecting_regions(button_event.x, button_event.y, 0, 0)
+            
             max_layer = self._find_max_layer(just_selected)
 
             was_selected = self.renderer.get_schedule().get_selected()
@@ -382,21 +412,21 @@ class GraphArea(gtk.DrawingArea):
                 # 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):
+                if just_selected:
+                    for event in just_selected[max_layer]:
+                        if not (more_than_one == 1 and max_layer in was_selected \
+                                and event in was_selected[max_layer]):
                             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]:
+                if just_selected:
+                    for event in just_selected[max_layer]:
+                        if max_layer in was_selected and event in was_selected[max_layer]:
                             self._select_event(remove_selected, event)
                         else:
                             self._select_event(add_selected, event)
@@ -566,40 +596,68 @@ 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)
 
         file_menu = gtk.Menu()
+        edit_menu = gtk.Menu()
         view_menu = gtk.Menu()
 
         agr = gtk.AccelGroup()
         self.add_accel_group(agr)
-
+        
+        # list of file items that are clickable if and only if at
+        # least one graph is viewable
+        self.sensitive_menu_items = []
+        
+        save_item = gtk.ImageMenuItem('_Save Graph to File')
+        img = gtk.Image()
+        img.set_from_stock(gtk.STOCK_SAVE_AS, gtk.ICON_SIZE_MENU)
+        save_item.set_image(img)
+        key, mod = gtk.accelerator_parse('<Ctrl>S')
+        save_item.add_accelerator('activate', agr, key, mod,
+            gtk.ACCEL_VISIBLE)
+        save_item.connect('activate', self.save_item_activate)
+        save_item.set_sensitive(False)
+        self.sensitive_menu_items.append(save_item)
+        
         quit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
-        key, mod = gtk.accelerator_parse('Q')
+        key, mod = gtk.accelerator_parse('<Ctrl>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(save_item)
         file_menu.append(quit_item)
 
         file_item = gtk.MenuItem('_File', True)
         file_item.set_submenu(file_menu)
-        file_item.show()
 
-        self.move_item = gtk.ImageMenuItem('_Move to Time')
+        move_item = gtk.ImageMenuItem('_Move to Time')
         key, mod = gtk.accelerator_parse('<Ctrl>M')
-        self.move_item.add_accelerator('activate', agr, key, mod,
+        move_item.add_accelerator('activate', agr, key, mod,
             gtk.ACCEL_VISIBLE)
-        self.move_item.set_sensitive(False)
-
-        self.move_item.connect('activate', self.move_to_time_activate)
-        self.move_item.show()
+        move_item.set_sensitive(False)
+        self.sensitive_menu_items.append(move_item)
+        
+        move_item.connect('activate', self.move_to_time_activate)
 
+        self.colors_item = gtk.ImageMenuItem('Co_lors')
+        key, mod = gtk.accelerator_parse('<Ctrl>L')
+        self.colors_item.add_accelerator('activate', agr, key, mod,
+            gtk.ACCEL_VISIBLE)
+        self.colors_item.set_sensitive(False)
+        
+        self.colors_item.connect('activate', self.colors_activate)
+        
+        edit_menu.append(self.colors_item)
+        
+        edit_item = gtk.MenuItem('_Edit', True)
+        edit_item.set_submenu(edit_menu)
+        
         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,
@@ -608,7 +666,6 @@ class MainWindow(gtk.Window):
         zoom_in_item.add_accelerator('activate', agr, key, mod, 0)
 
         zoom_in_item.connect('activate', self.zoom_in_item_activate)
-        zoom_in_item.show()
 
         zoom_out_item = gtk.ImageMenuItem(gtk.STOCK_ZOOM_OUT, agr)
         key, mod = gtk.accelerator_parse('<Ctrl>minus')
@@ -618,21 +675,19 @@ class MainWindow(gtk.Window):
         zoom_out_item.add_accelerator('activate', agr, key, mod, 0)
 
         zoom_out_item.connect('activate', self.zoom_out_item_activate)
-        zoom_out_item.show()
 
-        view_menu.append(self.move_item)
+        view_menu.append(move_item)
         view_menu.append(zoom_in_item)
         view_menu.append(zoom_out_item)
 
         view_item = gtk.MenuItem('_View', True)
         view_item.set_submenu(view_menu)
-        view_item.show()
 
         menu_bar = gtk.MenuBar()
         menu_bar.append(file_item)
+        menu_bar.append(edit_item)
         menu_bar.append(view_item)
 
-        menu_bar.show()
         self.vbox = gtk.VBox(False, 0)
 
         self.notebook = gtk.Notebook()
@@ -640,25 +695,24 @@ class MainWindow(gtk.Window):
         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_alignment(0.0, 0.0)
-        self.desc_label.show()
 
         self.vbox.pack_start(menu_bar, False, False, 0)
         self.vbox.pack_start(self.notebook, True, True, 0)
         self.vbox.pack_start(self.desc_label, False, False, 0)
-        self.vbox.show()
 
         self.add(self.vbox)
 
         self.info_win = InfoWindow()
-
+        self.color_dialog = gtk.ColorSelectionDialog('Choose Item Color')
+        
+        self.cur_item_no = None
+        
         self.set_size_request(MainWindow.WINDOW_WIDTH_REQ, MainWindow.WINDOW_HEIGHT_REQ)
 
         self.set_title('Unit-Trace Visualizer')
-        self.show()
+        self.show_all()
 
     def connect_widgets(self, gwindow):
         gwindow.get_graph_area().connect('update-event-description', self.update_event_description)
@@ -666,6 +720,7 @@ class MainWindow(gtk.Window):
         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)
+        gwindow.get_graph_area().connect('update-sel-changes', self.update_sel_changes)
 
     def set_renderers(self, renderers):
         for i in range(0, self.notebook.get_n_pages()):
@@ -675,15 +730,28 @@ class MainWindow(gtk.Window):
             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()
 
         if self.notebook.get_n_pages() > 0:
-            self.move_item.set_sensitive(True)
+            for menu_item in self.sensitive_menu_items:
+                menu_item.set_sensitive(True)
         else:
-            self.move_item.set_sensitive(False)
-
+            for menu_item in self.sensitive_menu_items:
+                menu_item.set_sensitive(False)
 
+    def update_sel_changes(self, widget, selected):
+        """Modify the GUI appropriately to reflect a change in selection."""
+        self.selected = selected
+        
+        self.cur_item_no = self.notebook.get_nth_page(self.notebook.last_page).get_graph_area() \
+                .get_graph().all_one_item_selected(selected)
+        if self.cur_item_no is not None:
+            self.colors_item.set_sensitive(True)
+        else:
+            self.colors_item.set_sensitive(False)    
+        
     def switch_page(self, widget, page, page_num):
         if self.notebook.get_nth_page(self.notebook.last_page) is not None:
             old_value = self.notebook.get_nth_page(self.notebook.last_page).get_hadjustment().get_value()
@@ -710,11 +778,12 @@ class MainWindow(gtk.Window):
         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()):
+            self.notebook.get_nth_page(i).get_graph_area().renderer.graph
             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)
-
+                break
+                
     def move_to_time_activate(self, widget):
         dialog = TextInputDialog('Move to Time', 'What time to move to?', self)
 
@@ -760,6 +829,93 @@ class MainWindow(gtk.Window):
         for i in range(0, self.notebook.get_n_pages()):
             self.notebook.get_nth_page(i).get_graph_area().zoom_out()
 
+    def colors_activate(self, widget):
+        garea = self.notebook.get_nth_page(self.notebook.last_page).get_graph_area()
+        graph = garea.get_renderer().get_graph()
+        
+        
+        pattern = graph.get_bar_pattern(self.cur_item_no)
+        
+        if len(pattern.get_color_list()) > 1:
+            print 'striped patterns not yet supported'
+        
+        r, g, b = pattern.get_color_list()[0]
+        colorsel = self.color_dialog.get_color_selection()
+        cur_color = gtk.gdk.Color(int(r * 65535), int(g * 65535), int(b * 65535))
+        colorsel.set_previous_color(cur_color)
+        colorsel.set_current_color(cur_color)
+        colorsel.set_has_palette(True)
+
+        if self.color_dialog.run() == gtk.RESPONSE_OK:
+            color = colorsel.get_current_color()
+            r, g, b = color.red / 65535.0, color.green / 65535.0, color.blue / 65535.0
+            graph.set_bar_pattern(self.cur_item_no, Pattern([(r, g, b)]))
+            garea.refresh_all()
+            
+        self.color_dialog.hide()
+        
+    def save_item_activate(self, widget):
+        ACCEPTED_TYPES = ('png', 'svg')
+        
+        dialog = gtk.FileChooserDialog('Save to Graphics File', self,
+                                        gtk.FILE_CHOOSER_ACTION_SAVE,
+                                        (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
+                                        gtk.STOCK_SAVE, gtk.RESPONSE_ACCEPT))
+        
+        png_filter = gtk.FileFilter()
+        png_filter.add_mime_type('image/png')
+        png_filter.set_name('PNG image (*.png)')
+        dialog.add_filter(png_filter)
+        
+        svg_filter = gtk.FileFilter()
+        svg_filter.add_mime_type('image/svg+xml')
+        svg_filter.set_name('SVG vector image (*.svg)')
+        dialog.add_filter(svg_filter)
+        
+        filename = None
+        ftype = None
+        while True:
+            if dialog.run() == gtk.RESPONSE_ACCEPT:
+                filename = dialog.get_filename()
+                # parse filename for extension
+            
+                parts = filename.split('.')
+                ftype = None
+                if len(parts) == 1:
+                    filename += '.' + parts[0]
+                    if dialog.get_filter() is png_filter:
+                        ftype = 'png'
+                    elif dialog.get_filter() is svg_filter:
+                        ftype = 'svg'
+                    break
+                else:
+                    ftype = parts[-1]
+                    if ftype in ACCEPTED_TYPES:
+                        break
+                    else:
+                        err_dialog = gtk.MessageDialog(self, gtk.DIALOG_DESTROY_WITH_PARENT,
+                                                         gtk.MESSAGE_ERROR,
+                                                         gtk.BUTTONS_CLOSE,
+                                                         'File type "' + ftype + '" not recognized')
+                        err_dialog.set_title('File Type Error')
+                        err_dialog.run()
+                        err_dialog.destroy()
+            else:
+                filename = None
+                ftype = None
+                break
+                
+        if filename is not None:
+            cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)
+            dialog.get_window().set_cursor(cursor)
+            def idle_callback(dialog):
+                self.notebook.get_nth_page(self.notebook.last_page).get_graph_area().output_to_file(filename, ftype)
+                dialog.get_window().set_cursor(None)
+                dialog.destroy()
+            gobject.idle_add(idle_callback, dialog) # needed to get the cursor to display
+        else:    
+            dialog.destroy()
+        
     def quit_item_activate(self, widget):
         self.destroy()