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

1 files changed, 170 insertions, 170 deletions

diff --git a/unit_trace/viz/canvas.py b/unit_trace/viz/canvas.py
index 758dea3..ea73d98 100644
--- a/unit_trace/viz/canvas.py
+++ b/unit_trace/viz/canvas.py
@@ -33,19 +33,19 @@ class Surface(object):
         self.scale = 1.0
         self.fname = fname
         self.ctx = ctx
-    
+
     def renew(self, width, height):
         raise NotImplementedError
-    
+
     def change_ctx(self, ctx):
         self.ctx = ctx
-            
+
     def get_fname(self):
         return self.fname
-        
+
     def write_out(self, fname):
         raise NotImplementedError
-        
+
     def pan(self, x, y, width, height):
         """A surface actually represents just a ``window'' into
         what we are drawing on. For instance, if we are scrolling through
@@ -57,11 +57,11 @@ class Surface(object):
         self.virt_y = y
         self.width = width
         self.height = height
-    
+
     def set_scale(self, scale):
         """Sets the scale factor."""
         self.scale = scale
-        
+
     def get_real_coor(self, x, y):
         """Translates the coordinates (x, y)
         in the ``theoretical'' plane to the true (x, y) coordinates on this surface
@@ -69,57 +69,57 @@ class Surface(object):
         bounds of the surface,
         if we want something outside the surface's ``window''."""
         return (x - self.virt_x * self.scale, y - self.virt_y * self.scale)
-    
+
     def get_virt_coor(self, x, y):
         """Does the inverse of the last method."""
         return (x + self.virt_x * self.scale, y + self.virt_y * self.scale)
-    
+
     def get_virt_coor_unscaled(self, x, y):
         """Does the same, but removes the scale factor (i.e. behaves as if
         the scale was 1.0 all along)."""
         return (x / self.scale + self.virt_x, y / self.scale + self.virt_y)
-            
+
 class SVGSurface(Surface):
     def renew(self, width, height):
         iwidth = int(math.ceil(width))
         iheight = int(math.ceil(height))
         self.surface = cairo.SVGSurface(self.fname, iwidth, iheight)
         self.ctx = cairo.Context(self.surface)
-        
+
     def write_out(self, fname):
         os.execl('cp', self.fname, fname)
-    
+
 class ImageSurface(Surface):
     def renew(self, width, height):
         iwidth = int(math.ceil(width))
         iheight = int(math.ceil(height))
         self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, iwidth, iheight)
         self.ctx = cairo.Context(self.surface)
-            
+
     def write_out(self, fname):
         if self.surface is None:
             raise ValueError('Don\'t own surface, can\'t write to to file')
-        
+
         self.surface.write_to_png(fname)
 
 class Pattern(object):
     DEF_STRIPE_SIZE = 10
     MAX_FADE_WIDTH = 250
-    
+
     def __init__(self, color_list, stripe_size=DEF_STRIPE_SIZE):
         self.color_list = color_list
         self.stripe_size = stripe_size
-         
+
     def render_on_canvas(self, canvas, x, y, width, height, fade=False):
         fade_span = min(width, Pattern.MAX_FADE_WIDTH)
-        
+
         if len(self.color_list) == 1:
             if fade:
                 canvas.fill_rect_fade(x, y, fade_span, height, (1.0, 1.0, 1.0), \
                     self.color_list[0])
             else:
                 canvas.fill_rect(x, y, width, height, self.color_list[0])
-            
+
             if width > Pattern.MAX_FADE_WIDTH:
                     canvas.fill_rect(x + Pattern.MAX_FADE_WIDTH, y, width - Pattern.MAX_FADE_WIDTH,
                                      height, self.color_list[0])
@@ -133,100 +133,100 @@ class Pattern(object):
                         min(self.stripe_size, bottom - y), (1.0, 1.0, 1.0), self.color_list[i])
                 else:
                     canvas.fill_rect(x, y, width, min(self.stripe_size, bottom - y), self.color_list[i])
-                
+
                 if width > Pattern.MAX_FADE_WIDTH:
                     canvas.fill_rect(x + Pattern.MAX_FADE_WIDTH, y, width - Pattern.MAX_FADE_WIDTH,
                                      min(self.stripe_size, bottom - y), self.color_list[i])
-                    
+
                 y += self.stripe_size
                 n += 1
-        
+
 class Canvas(object):
     """This is a basic class that stores and draws on a Cairo surface,
     using various primitives related to drawing a real-time graph (up-arrows,
     down-arrows, bars, ...).
-    
+
     This is the lowest-level representation (aside perhaps from the Cairo
     surface itself) of a real-time graph. It allows the user to draw
     primitives at certain locations, but for the most part does not know
     anything about real-time scheduling, just how to draw the basic parts
     that make up a schedule graph. For that, see Graph or its descendants."""
-    
+
     BOTTOM_LAYER = 0
     MIDDLE_LAYER = 1
     TOP_LAYER = 2
-    
+
     LAYERS = (BOTTOM_LAYER, MIDDLE_LAYER, TOP_LAYER)
-    
+
     NULL_PATTERN = -1
-    
+
     SQRT3 = math.sqrt(3.0)
-    
+
     def __init__(self, width, height, item_clist, bar_plist, surface):
         """Creates a new Canvas of dimensions (width, height). The
         parameters ``item_plist'' and ``bar_plist'' each specify a list
         of patterns to choose from when drawing the items on the y-axis
         or filling in bars, respectively."""
-        
+
         self.surface = surface
-        
+
         self.width = int(math.ceil(width))
         self.height = int(math.ceil(height))
         self.item_clist = item_clist
         self.bar_plist = bar_plist
-        
+
         self.selectable_regions = {}
-        
+
         self.scale = 1.0
 
     # clears the canvas.
     def clear(self):
         raise NotImplementedError
-    
+
     def set_scale(self, scale):
         self.scale = scale
         self.surface.set_scale(scale)
         for event in self.selectable_regions:
             self.selectable_regions[event].set_scale(scale)
-        
+
     def scaled(self, *coors):
         """Scales a series of coordinates."""
         return [coor * self.scale for coor in coors]
-    
+
     def unscaled(self, *coors):
         """Inverse of scale()."""
         return [coor / self.scale for coor in coors]
-        
+
     def draw_rect(self, x, y, width, height, color, thickness, snap=True):
         """Draws a rectangle somewhere (border only)."""
         raise NotImplementedError
-    
+
     def fill_rect(self, x, y, width, height, color, snap=True):
         """Draws a filled rectangle somewhere. ``color'' is a 3-tuple."""
         raise NotImplementedError
-    
+
     def fill_rect_fade(self, x, y, width, height, lcolor, rcolor, snap=True):
         """Draws a rectangle somewhere, filled in with the fade."""
         raise NotImplementedError
-            
+
     def draw_line(self, p0, p1, color, thickness, snap=True):
         """Draws a line from p0 to p1 with a certain color and thickness."""
         raise NotImplementedError
-        
+
     def draw_polyline(self, coor_list, color, thickness, snap=True):
         """Draws a polyline, where coor_list = [(x_0, y_0), (x_1, y_1), ... (x_m, y_m)]
         specifies a polyline from (x_0, y_0) to (x_1, y_1), etc."""
         raise NotImplementedError
-    
+
     def fill_polyline(self, coor_list, color, thickness, snap=True):
         """Draws a polyline (probably a polygon) and fills it."""
         raise NotImplementedError
-            
+
     def draw_label(self, text, x, y, fopts=GraphFormat.DEF_FOPTS_LABEL,
                    halign=AlignMode.LEFT, valign=AlignMode.BOTTOM, snap=True):
         """Draws text at a position with a certain alignment."""
-        raise NotImplementedError   
-    
+        raise NotImplementedError
+
     def draw_label_with_sscripts(self, text, supscript, subscript, x, y, \
                                  textfopts=GraphFormat.DEF_FOPTS_LABEL,
                                  sscriptfopts=GraphFormat.DEF_FOPTS_LABEL_SSCRIPT, \
@@ -234,31 +234,31 @@ class Canvas(object):
         """Draws text at a position with a certain alignment, along with optionally a superscript and
         subscript (which are None if either is not used.)"""
         raise NotImplementedError
-    
+
     def draw_y_axis(self, x, y, height):
         """Draws the y-axis, starting from the bottom at the point x, y."""
         self.surface.ctx.set_source_rgb(0.0, 0.0, 0.0)
-        
+
         self.draw_line((x, y), (x, y - height), (0.0, 0.0, 0.0), GraphFormat.AXIS_THICKNESS)
-        
+
     def draw_y_axis_labels(self, x, y, height, item_list, item_size, fopts=None):
         """Draws the item labels on the y-axis. ``item_list'' is the list
         of strings to print, while item_size gives the vertical amount of
         space that each item shall take up, in pixels."""
         if fopts is None:
             fopts = GraphFormat.DEF_FOPTS_ITEM
-        
+
         x -= GraphFormat.Y_AXIS_ITEM_GAP
         y -= height - item_size / 2.0
-        
+
         orig_color = fopts.color
         for ctr, item in enumerate(item_list):
             fopts.color = self.get_item_color(ctr)
             self.draw_label(item, x, y, fopts, AlignMode.RIGHT, AlignMode.CENTER)
             y += item_size
-        
+
         fopts.color = orig_color
-        
+
     def draw_x_axis(self, x, y, start_tick, end_tick, maj_sep, min_per_maj):
         """Draws the x-axis, including all the major and minor ticks (but not the labels).
         ``num_maj'' gives the number of major ticks, ``maj_sep'' the number of pixels between
@@ -271,48 +271,48 @@ class Canvas(object):
         for i in range(start_tick, end_tick + 1):
             self.draw_line((x, y), (x, y + GraphFormat.MAJ_TICK_SIZE),
                            (0.0, 0.0, 0.0), GraphFormat.AXIS_THICKNESS)
-            
+
             if (i < end_tick):
                 for j in range(0, min_per_maj):
                     self.draw_line((x, y), (x + maj_sep / min_per_maj, y),
                         (0.0, 0.0, 0.0), GraphFormat.AXIS_THICKNESS)
-                    
+
                     x += 1.0 * maj_sep / min_per_maj
                     if j < min_per_maj - 1:
                         self.draw_line((x, y), (x, y + GraphFormat.MIN_TICK_SIZE),
                         (0.0, 0.0, 0.0), GraphFormat.AXIS_THICKNESS)
-        
+
     def draw_x_axis_labels(self, x, y, start_tick, end_tick, maj_sep, min_per_maj, start=0, incr=1, show_min=False, \
                            majfopts=GraphFormat.DEF_FOPTS_MAJ, minfopts=GraphFormat.DEF_FOPTS_MIN):
         """Draws the labels for the x-axis. (x, y) should give the origin.
         how far down you want the text. ``incr'' gives the increment per major
         tick. ``start'' gives the value of the first tick. ``show_min'' specifies
         whether to draw labels at minor ticks."""
-            
+
         x += GraphFormat.X_AXIS_MEASURE_OFS + start_tick * maj_sep
         y += GraphFormat.X_AXIS_LABEL_GAP + GraphFormat.MAJ_TICK_SIZE
-        
+
         minincr = incr / (min_per_maj * 1.0)
-        
+
         cur = start * 1.0
-        
-        for i in range(start_tick, end_tick + 1):    
+
+        for i in range(start_tick, end_tick + 1):
             text = util.format_float(cur, 2)
             self.draw_label(text, x, y, majfopts, AlignMode.CENTER, AlignMode.TOP)
-            
+
             if (i < end_tick):
                 if show_min:
                     for j in range(0, min_per_maj):
                         x += 1.0 * maj_sep / min_per_maj
                         cur += minincr
                         text = util.format_float(cur, 2)
-                    
+
                         if j < min_per_maj - 1:
                             self.draw_label(text, x, y, minfopts, AlignMode.CENTER, AlignMode.TOP)
                 else:
                     x += maj_sep
                     cur += incr
-    
+
     def draw_grid(self, x, y, height, start_tick, end_tick, start_item, end_item, maj_sep, item_size, \
                   min_per_maj=None, show_min=False):
         """Draws a grid dividing along the item boundaries and the major ticks.
@@ -321,22 +321,22 @@ class Canvas(object):
         ``start_item'' and ``end_item'' give the item boundaries to start and end drawing horizontal lines."""
         if start_tick > end_tick or start_item > end_item:
             return
-            
+
         line_width = (end_tick - start_tick) * maj_sep
         line_height = (end_item - start_item) * item_size
-        
+
         origin = (x, y)
-        
+
         # draw horizontal lines first
-        x = origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + start_tick * maj_sep 
+        x = origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + start_tick * maj_sep
         y = origin[1] - height + start_item * item_size
         for i in range(start_item, end_item + 1):
             self.draw_line((x, y), (x + line_width, y), GraphFormat.GRID_COLOR, GraphFormat.GRID_THICKNESS)
             y += item_size
-        
-        x = origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + start_tick * maj_sep 
+
+        x = origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + start_tick * maj_sep
         y = origin[1] - height + start_item * item_size
-        
+
         if show_min:
             for i in range(0, (end_tick - start_tick) * min_per_maj + 1):
                 self.draw_line((x, y), (x, y + line_height), GraphFormat.GRID_COLOR, GraphFormat.GRID_THICKNESS)
@@ -345,222 +345,222 @@ class Canvas(object):
             for i in range(start_tick, end_tick + 1):
                 self.draw_line((x, y), (x, y + line_height), GraphFormat.GRID_COLOR, GraphFormat.GRID_THICKNESS)
                 x += maj_sep
-                          
+
     def draw_bar(self, x, y, width, height, n, clip_side, selected):
         """Draws a bar with a certain set of dimensions, using pattern ``n'' from the
         bar pattern list."""
-        
+
         color, thickness = {False : (GraphFormat.BORDER_COLOR, GraphFormat.BORDER_THICKNESS),
                             True : (GraphFormat.HIGHLIGHT_COLOR, GraphFormat.BORDER_THICKNESS * 2.0)}[selected]
-                            
+
         # use a pattern to be pretty
         self.get_bar_pattern(n).render_on_canvas(self, x, y, width, height, True)
-        
+
         self.draw_rect(x, y, width, height, color, thickness, clip_side)
-    
+
     def add_sel_bar(self, x, y, width, height, event):
         self.add_sel_region(SelectableRegion(x, y, width, height, event))
-        
+
     def draw_mini_bar(self, x, y, width, height, n, clip_side, selected):
         """Like the above, except it draws a miniature version. This is usually used for
         secondary purposes (i.e. to show jobs that _should_ have been running at a certain time).
-        
+
         Of course we don't enforce the fact that this is mini, since the user can pass in width
         and height (but the mini bars do look slightly different: namely the borders are a different
         color)"""
-        
+
         color, thickness = {False : (GraphFormat.LITE_BORDER_COLOR, GraphFormat.BORDER_THICKNESS),
                             True : (GraphFormat.HIGHLIGHT_COLOR, GraphFormat.BORDER_THICKNESS * 1.5)}[selected]
-        
+
         self.get_bar_pattern(n).render_on_canvas(self, x, y, width, height, True)
-        
+
         self.draw_rect(x, y, width, height, color, thickness, clip_side)
-        
+
     def add_sel_mini_bar(self, x, y, width, height, event):
         self.add_sel_region(SelectableRegion(x, y, width, height, event))
-                                
+
     def draw_completion_marker(self, x, y, height, selected):
         """Draws the symbol that represents a job completion, using a certain height."""
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
         self.draw_line((x - height * GraphFormat.TEE_FACTOR / 2.0, y),
                        (x + height * GraphFormat.TEE_FACTOR / 2.0, y),
                        color, GraphFormat.BORDER_THICKNESS)
         self.draw_line((x, y), (x, y + height), color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_completion_marker(self, x, y, height, event):
         self.add_sel_region(SelectableRegion(x - height * GraphFormat.TEE_FACTOR / 2.0, y,
             height * GraphFormat.TEE_FACTOR, height, event))
-                       
+
     def draw_release_arrow_big(self, x, y, height, selected):
         """Draws a release arrow of a certain height: (x, y) should give the top
         (northernmost point) of the arrow. The height includes the arrowhead."""
         big_arrowhead_height = GraphFormat.BIG_ARROWHEAD_FACTOR * height
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
         colors = [(1.0, 1.0, 1.0), color]
         draw_funcs = [self.__class__.fill_polyline, self.__class__.draw_polyline]
         for i in range(0, 2):
             color = colors[i]
             draw_func = draw_funcs[i]
-            
+
             draw_func(self, [(x, y), (x - big_arrowhead_height / Canvas.SQRT3, y + big_arrowhead_height), \
                        (x + big_arrowhead_height / Canvas.SQRT3, y + big_arrowhead_height), (x, y)], \
                        color, GraphFormat.BORDER_THICKNESS)
-        
+
         self.draw_line((x, y + big_arrowhead_height), (x, y + height), color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_release_arrow_big(self, x, y, height, event):
         self.add_sel_arrow_big(x, y, height, event)
-            
+
     def draw_deadline_arrow_big(self, x, y, height, selected):
         """Draws a release arrow: x, y should give the top (northernmost
         point) of the arrow. The height includes the arrowhead."""
         big_arrowhead_height = GraphFormat.BIG_ARROWHEAD_FACTOR * height
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
         colors = [(1.0, 1.0, 1.0), color]
         draw_funcs = [self.__class__.fill_polyline, self.__class__.draw_polyline]
         for i in range(0, 2):
             color = colors[i]
             draw_func = draw_funcs[i]
-            
+
             draw_func(self, [(x, y + height), (x - big_arrowhead_height / Canvas.SQRT3, \
                         y + height - big_arrowhead_height), \
                         (x + big_arrowhead_height / Canvas.SQRT3, \
                         y + height - big_arrowhead_height), \
                         (x, y + height)], color, GraphFormat.BORDER_THICKNESS)
-        
+
         self.draw_line((x, y), (x, y + height - big_arrowhead_height),
                        color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_deadline_arrow_big(self, x, y, height, event):
         self.add_sel_arrow_big(x, y, height, event)
-    
+
     def add_sel_arrow_big(self, x, y, height, event):
         big_arrowhead_height = GraphFormat.BIG_ARROWHEAD_FACTOR * height
-        
+
         self.add_sel_region(SelectableRegion(x - big_arrowhead_height / Canvas.SQRT3,
             y, 2.0 * big_arrowhead_height / Canvas.SQRT3, height, event))
-                        
+
     def draw_release_arrow_small(self, x, y, height, selected):
         """Draws a small release arrow (most likely coming off the x-axis, although
         this method doesn't enforce this): x, y should give the top of the arrow"""
         small_arrowhead_height = GraphFormat.SMALL_ARROWHEAD_FACTOR * height
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
-        
+
         self.draw_line((x, y), (x - small_arrowhead_height, y + small_arrowhead_height), \
                        color, GraphFormat.BORDER_THICKNESS)
         self.draw_line((x, y), (x + small_arrowhead_height, y + small_arrowhead_height), \
                        color, GraphFormat.BORDER_THICKNESS)
         self.draw_line((x, y), (x, y + height), color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_release_arrow_small(self, x, y, height, event):
         self.add_sel_arrow_small(x, y, height, event)
-        
+
     def draw_deadline_arrow_small(self, x, y, height, selected):
         """Draws a small deadline arrow (most likely coming off the x-axis, although
         this method doesn't enforce this): x, y should give the top of the arrow"""
         small_arrowhead_height = GraphFormat.SMALL_ARROWHEAD_FACTOR * height
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
-        
+
         self.draw_line((x, y), (x, y + height), color, GraphFormat.BORDER_THICKNESS)
         self.draw_line((x - small_arrowhead_height, y + height - small_arrowhead_height), \
                        (x, y + height), color, GraphFormat.BORDER_THICKNESS)
         self.draw_line((x + small_arrowhead_height, y + height - small_arrowhead_height), \
                        (x, y + height), color, GraphFormat.BORDER_THICKNESS)
-        
+
     def add_sel_deadline_arrow_small(self, x, y, height, event):
         self.add_sel_arrow_small(x, y, height, event)
-    
+
     def add_sel_arrow_small(self, x, y, height, event):
         small_arrowhead_height = GraphFormat.SMALL_ARROWHEAD_FACTOR * height
-        
+
         self.add_sel_region(SelectableRegion(x - small_arrowhead_height, y,
             small_arrowhead_height * 2.0, height, event))
-            
+
     def draw_suspend_triangle(self, x, y, height, selected):
         """Draws the triangle that marks a suspension. (x, y) gives the topmost (northernmost) point
         of the symbol."""
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
         colors = [(0.0, 0.0, 0.0), color]
-        
+
         draw_funcs = [self.__class__.fill_polyline, self.__class__.draw_polyline]
         for i in range(0, 2):
             color = colors[i]
             draw_func = draw_funcs[i]
             draw_func(self, [(x, y), (x + height / 2.0, y + height / 2.0), (x, y + height), (x, y)], \
                       color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_suspend_triangle(self, x, y, height, event):
         self.add_sel_region(SelectableRegion(x, y, height / 2.0, height, event))
-        
+
     def draw_resume_triangle(self, x, y, height, selected):
         """Draws the triangle that marks a resumption. (x, y) gives the topmost (northernmost) point
         of the symbol."""
-        
+
         color = {False : GraphFormat.BORDER_COLOR, True : GraphFormat.HIGHLIGHT_COLOR}[selected]
         colors = [(1.0, 1.0, 1.0), color]
-        
+
         draw_funcs = [self.__class__.fill_polyline, self.__class__.draw_polyline]
         for i in range(0, 2):
             color = colors[i]
             draw_func = draw_funcs[i]
             draw_func(self, [(x, y), (x - height / 2.0, y + height / 2.0), (x, y + height), (x, y)], \
                       color, GraphFormat.BORDER_THICKNESS)
-    
+
     def add_sel_resume_triangle(self, x, y, height, event):
         self.add_sel_region(SelectableRegion(x - height / 2.0, y, height / 2.0, height, event))
-    
+
     def clear_selectable_regions(self):
         self.selectable_regions = {}
-            
+
     #def clear_selectable_regions(self, real_x, real_y, width, height):
     #    x, y = self.surface.get_virt_coor(real_x, real_y)
     #    for event in self.selectable_regions.keys():
     #        if self.selectable_regions[event].intersects(x, y, width, height):
     #            del self.selectable_regions[event]
-        
+
     def add_sel_region(self, region):
         region.set_scale(self.scale)
         self.selectable_regions[region.get_event()] = region
-    
+
     def get_sel_region(self, event):
         return self.selectable_regions[event]
-    
+
     def has_sel_region(self, event):
         return event in self.selectable_regions
-                
+
     def get_selected_regions(self, real_x, real_y, width, height):
         x, y = self.surface.get_virt_coor(real_x, real_y)
-    
+
         selected = {}
         for event in self.selectable_regions:
             region = self.selectable_regions[event]
             if region.intersects(x, y, width, height):
                 selected[event] = region
-        
+
         return selected
-        
+
     def whiteout(self):
         """Overwrites the surface completely white, but technically doesn't delete anything"""
         # Make sure we don't scale here (we want to literally white out just this region)
-        
+
         x, y = self.surface.get_virt_coor_unscaled(0, 0)
         width, height = self.unscaled(self.surface.width, self.surface.height)
-        
+
         self.fill_rect(x, y, width, height, (1.0, 1.0, 1.0), False)
-            
+
     def get_item_color(self, n):
         """Gets the nth color in the item color list, which are the colors used to draw the items
         on the y-axis. Note that there are conceptually infinitely
         many patterns because the patterns repeat -- that is, we just mod out by the size of the pattern
         list when indexing."""
         return self.item_clist[n % len(self.item_clist)]
-    
+
     def get_bar_pattern(self, n):
         """Gets the nth pattern in the bar pattern list, which is a list of surfaces that are used to
         fill in the bars. Note that there are conceptually infinitely
@@ -574,38 +574,38 @@ class CairoCanvas(Canvas):
     """This is a basic class that stores and draws on a Cairo surface,
     using various primitives related to drawing a real-time graph (up-arrows,
     down-arrows, bars, ...).
-    
+
     This is the lowest-level non-abstract representation
     (aside perhaps from the Cairo surface itself) of a real-time graph.
     It allows the user to draw primitives at certain locations, but for
     the most part does not know anything about real-time scheduling,
     just how to draw the basic parts that make up a schedule graph.
     For that, see Graph or its descendants."""
-    
+
     #def __init__(self, fname, width, height, item_clist, bar_plist, surface):
     #    """Creates a new Canvas of dimensions (width, height). The
     #    parameters ``item_plist'' and ``bar_plist'' each specify a list
     #    of patterns to choose from when drawing the items on the y-axis
     #    or filling in bars, respectively."""
-        
+
     #    super(CairoCanvas, self).__init__(fname, width, height, item_clist, bar_plist, surface)
-    
+
     #def clear(self):
     #    self.surface = self.SurfaceType(self.width, self.height, self.fname)
     #    self.whiteout()
-        
+
     def get_surface(self):
         """Gets the Surface that we are drawing on in its current state."""
         return self.surface
-    
+
     def _rect_common(self, x, y, width, height, color, thickness, clip_side=None, do_snap=True):
         EXTRA_FACTOR = 2.0
-        
+
         x, y, width, height = self.scaled(x, y, width, height)
         x, y = self.surface.get_real_coor(x, y)
         max_width = self.surface.width + EXTRA_FACTOR * thickness
         max_height = self.surface.height + EXTRA_FACTOR * thickness
-        
+
         # if dimensions are really large this can cause Cairo problems --
         # so clip it to the size of the surface, which is the only part we see anyway
         if x < 0:
@@ -618,11 +618,11 @@ class CairoCanvas(Canvas):
             width = max_width
         if height > max_height:
             height = max_height
-            
+
         if do_snap:
             x = snap(x)
             y = snap(y)
-            
+
         if clip_side == AlignMode.LEFT:
             self.surface.ctx.move_to(x, y)
             self.surface.ctx.line_to(x + width, y)
@@ -636,23 +636,23 @@ class CairoCanvas(Canvas):
         else:
             # don't clip one edge of the rectangle -- just draw a Cairo rectangle
             self.surface.ctx.rectangle(x, y, width, height)
-            
+
         self.surface.ctx.set_line_width(thickness * self.scale)
         self.surface.ctx.set_source_rgb(color[0], color[1], color[2])
-        
+
     def draw_rect(self, x, y, width, height, color, thickness, clip_side=None, do_snap=True):
         self._rect_common(x, y, width, height, color, thickness, clip_side, do_snap)
         self.surface.ctx.stroke()
-    
+
     def fill_rect(self, x, y, width, height, color, do_snap=True):
         self._rect_common(x, y, width, height, color, 1, do_snap)
         self.surface.ctx.fill()
-    
+
     def fill_rect_fade(self, x, y, width, height, lcolor, rcolor, do_snap=True):
         """Draws a rectangle somewhere, filled in with the fade."""
         x, y, width, height = self.scaled(x, y, width, height)
         x, y = self.surface.get_real_coor(x, y)
-        
+
         if do_snap:
             linear = cairo.LinearGradient(snap(x), snap(y), \
                                       snap(x + width), snap(y + height))
@@ -667,7 +667,7 @@ class CairoCanvas(Canvas):
         else:
             self.surface.ctx.rectangle(x, y, width, height)
         self.surface.ctx.fill()
-            
+
     def draw_line(self, p0, p1, color, thickness, do_snap=True):
         """Draws a line from p0 to p1 with a certain color and thickness."""
         p0 = self.scaled(p0[0], p0[1])
@@ -677,36 +677,36 @@ class CairoCanvas(Canvas):
         if do_snap:
             p0 = (snap(p0[0]), snap(p0[1]))
             p1 = (snap(p1[0]), snap(p1[1]))
-            
+
         self.surface.ctx.move_to(p0[0], p0[1])
         self.surface.ctx.line_to(p1[0], p1[1])
         self.surface.ctx.set_source_rgb(color[0], color[1], color[2])
         self.surface.ctx.set_line_width(thickness * self.scale)
         self.surface.ctx.stroke()
-        
+
     def _polyline_common(self, coor_list, color, thickness, do_snap=True):
         scaled_coor_list = [self.scaled(coor[0], coor[1]) for coor in coor_list]
         real_coor_list = [self.surface.get_real_coor(coor[0], coor[1]) for coor in scaled_coor_list]
-        
+
         self.surface.ctx.move_to(real_coor_list[0][0], real_coor_list[0][1])
         if do_snap:
             for i in range(0, len(real_coor_list)):
                 real_coor_list[i] = (snap(real_coor_list[i][0]), snap(real_coor_list[i][1]))
-                
+
         for coor in real_coor_list[1:]:
             self.surface.ctx.line_to(coor[0], coor[1])
-        
-        self.surface.ctx.set_line_width(thickness * self.scale)    
+
+        self.surface.ctx.set_line_width(thickness * self.scale)
         self.surface.ctx.set_source_rgb(color[0], color[1], color[2])
-        
+
     def draw_polyline(self, coor_list, color, thickness, do_snap=True):
         self._polyline_common(coor_list, color, thickness, do_snap)
         self.surface.ctx.stroke()
-        
+
     def fill_polyline(self, coor_list, color, thickness, do_snap=True):
         self._polyline_common(coor_list, color, thickness, do_snap)
         self.surface.ctx.fill()
-     
+
     def _draw_label_common(self, text, x, y, fopts, x_bearing_factor, \
                            f_descent_factor, width_factor, f_height_factor, do_snap=True):
         """Helper function for drawing a label with some alignment. Instead of taking in an alignment,
@@ -714,30 +714,30 @@ class CairoCanvas(Canvas):
         the x and y parameters. Only should be used internally."""
         x, y = self.scaled(x, y)
         x, y = self.surface.get_real_coor(x, y)
-        
+
         self.surface.ctx.set_source_rgb(0.0, 0.0, 0.0)
-            
+
         self.surface.ctx.select_font_face(fopts.name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
         self.surface.ctx.set_font_size(fopts.size * self.scale)
-        
+
         fe = self.surface.ctx.font_extents()
         f_ascent, f_descent, f_height = fe[:3]
-        
+
         te = self.surface.ctx.text_extents(text)
         x_bearing, y_bearing, width, height = te[:4]
-        
+
         actual_x = x - x_bearing * x_bearing_factor - width * width_factor
         actual_y = y - f_descent * f_descent_factor + f_height * f_height_factor
-        
+
         self.surface.ctx.set_source_rgb(fopts.color[0], fopts.color[1], fopts.color[2])
-        
+
         if do_snap:
             self.surface.ctx.move_to(snap(actual_x), snap(actual_y))
         else:
             self.surface.ctx.move_to(actual_x, actual_y)
-                    
+
         self.surface.ctx.show_text(text)
-        
+
     def draw_label(self, text, x, y, fopts=GraphFormat.DEF_FOPTS_LABEL, halign=AlignMode.LEFT, valign=AlignMode.BOTTOM, do_snap=True):
         """Draws a label with the given parameters, with the given horizontal and vertical justification. One can override
         the color from ``fopts'' by passing something in to ``pattern'', which overrides the color with an arbitrary
@@ -747,21 +747,21 @@ class CairoCanvas(Canvas):
         if halign not in halign_factors:
             raise ValueError('Invalid alignment value')
         x_bearing_factor, width_factor = halign_factors[halign]
-        
+
         valign_factors = {AlignMode.BOTTOM : (0.0, 0.0), AlignMode.CENTER : (1.0, 0.5), AlignMode.TOP : (1.0, 1.0)}
         if valign not in valign_factors:
             raise ValueError('Invalid alignment value')
         f_descent_factor, f_height_factor = valign_factors[valign]
-            
+
         self._draw_label_common(text, x, y, fopts, x_bearing_factor, \
-                f_descent_factor, width_factor, f_height_factor, do_snap)    
-    
+                f_descent_factor, width_factor, f_height_factor, do_snap)
+
     def draw_label_with_sscripts(self, text, supscript, subscript, x, y, \
                                  textfopts=GraphFormat.DEF_FOPTS_LABEL, sscriptfopts=GraphFormat.DEF_FOPTS_LABEL_SSCRIPT, \
                                 halign=AlignMode.LEFT, valign=AlignMode.BOTTOM, do_snap=True):
         """Draws a label, but also optionally allows a superscript and subscript to be rendered."""
         self.draw_label(text, x, y, textfopts, halign, valign)
-        
+
         self.surface.ctx.set_source_rgb(0.0, 0.0, 0.0)
         self.surface.ctx.select_font_face(textfopts.name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
         self.surface.ctx.set_font_size(textfopts.size)
@@ -781,7 +781,7 @@ class CairoCanvas(Canvas):
             ytmp = y
             ytmp = y + f_height / 4.0
             self.draw_label(subscript, xtmp, ytmp, sscriptfopts, halign, valign, do_snap)
-        
+
 # represents a selectable region of the graph
 class SelectableRegion(object):
     def __init__(self, x, y, width, height, event):
@@ -791,19 +791,19 @@ class SelectableRegion(object):
         self.height = height
         self.event = event
         self.scale = 1.0
-    
+
     def get_dimensions(self):
         return (self.x, self.y, self.width, self.height)
-        
+
     def get_event(self):
         return self.event
-    
+
     def set_scale(self, scale):
         self.scale = scale
-        
+
     def intersects(self, x, y, width, height):
         return x <= (self.x + self.width) * self.scale \
            and x + width >= self.x * self.scale \
            and y <= (self.y + self.height) * self.scale \
            and y + height >= self.y * self.scale
-        
+