Zapped a bunch of trailing whitespace

author: Mac Mollison <mollison@cs.unc.edu> 2010-03-20 17:40:00 -0400
committer: Mac Mollison <mollison@cs.unc.edu> 2010-03-20 17:40:00 -0400
commit: 90d1825ad3ad20430734c1c75b899d14c4e6b700 (patch)
tree: 834a898b506f37a35c73d3845061ec8f7284394e
parent: 7fdb4dbbbca577efbeec47cd1364eb319346a0cc (diff)
14 files changed, 607 insertions, 607 deletions
diff --git a/install.py b/install.py
index 935c7df..b06462c 100755
--- a/install.py
+++ b/install.py
@@ -4,8 +4,8 @@
 # Description
 ################################################################################
-# This script installes (or re-installs) the unit_trace Python module, so that 
+# This script installes (or re-installs) the unit_trace Python module, so that
-# the unit_trace library can be imported with `import unit_trace` by a Python 
+# the unit_trace library can be imported with `import unit_trace` by a Python
 # script, from anywhere on the system.
 # The installation merely consists of copying the unit_trace directory to
diff --git a/unit_trace/naive_trace_reader.py b/unit_trace/naive_trace_reader.py
index 0f117b8..0f45895 100644
--- a/unit_trace/naive_trace_reader.py
+++ b/unit_trace/naive_trace_reader.py
@@ -31,18 +31,18 @@ def trace_reader(files):
            data = f.read(RECORD_HEAD_SIZE)
            try:
                type_num = struct.unpack_from('b',data)[0]
-            except struct.error: 
+            except struct.error:
                break #We read to the end of the file
            type = _get_type(type_num)
            try:
-                values = struct.unpack_from(StHeader.format + 
+                values = struct.unpack_from(StHeader.format +
                    type.format,data)
                record_dict = dict(zip(type.keys,values))
            except struct.error:
                f.close()
                print "Invalid record detected, stopping."
                exit()
-                
            # Convert the record_dict into an object
            record = _dict2obj(record_dict)
@@ -69,7 +69,7 @@ def _dict2obj(d):
    o = Obj()
    for key in d.keys():
        o.__dict__[key] = d[key]
-    return o 
+    return o
 ###############################################################################
 # Trace record data types and accessor functions
@@ -95,7 +95,7 @@ class StNameData(object):
    keys = StHeader.keys + ['name']
    message = 'The name of the executable of this process.'
-class StParamData(object):  
+class StParamData(object):
    format =  'IIIc'
    formatStr = struct.Struct(StHeader.format + format)
    keys = StHeader.keys + ['wcet','period','phase','partition']
@@ -107,7 +107,7 @@ class StReleaseData(object):
    keys = StHeader.keys + ['when','deadline']
    message = 'A job was/is going to be released.'
-#Not yet used by Sched Trace 
+#Not yet used by Sched Trace
 class StAssignedData(object):
    format =  'Qc'
    formatStr = struct.Struct(StHeader.format + format)
diff --git a/unit_trace/progress.py b/unit_trace/progress.py
index d987ecd..d0f0482 100644
--- a/unit_trace/progress.py
+++ b/unit_trace/progress.py
@@ -25,7 +25,7 @@ def progress(stream):
    start_time = 0
    count = 0
-    
    for record in stream:
        if record.record_type=="event":
            count += 1
diff --git a/unit_trace/sanitizer.py b/unit_trace/sanitizer.py
index 79315cc..598379a 100644
--- a/unit_trace/sanitizer.py
+++ b/unit_trace/sanitizer.py
@@ -49,5 +49,5 @@ def sanitizer(stream):
        if record.type_name == 'switch_away':
            if (record.pid,record.job) not in jobs_switched_to:
                record.job -= 1
-        
        yield record
diff --git a/unit_trace/stats.py b/unit_trace/stats.py
index 34a842f..17c5fc9 100644
--- a/unit_trace/stats.py
+++ b/unit_trace/stats.py
@@ -32,7 +32,7 @@ def stats(stream):
    rec = Obj()
    rec.record_type = "meta"
    rec.type_name = "stats"
-    rec.num_inversions = num_inversions 
+    rec.num_inversions = num_inversions
    rec.min_inversion = min_inversion
    rec.max_inversion = max_inversion
    rec.avg_inversion = avg_inversion
diff --git a/unit_trace/stdout_printer.py b/unit_trace/stdout_printer.py
index f8d9a84..8842b71 100644
--- a/unit_trace/stdout_printer.py
+++ b/unit_trace/stdout_printer.py
@@ -62,7 +62,7 @@ def _print_inversion_end(record):
    print #newline
 def _print_stats(record):
-    print "Inversion statistics" 
+    print "Inversion statistics"
    print "Num inversions: %d" % (record.num_inversions)
    print "Min inversion: %d" % (record.min_inversion)
    print "Max inversion: %d" % (record.max_inversion)
diff --git a/unit_trace/trace_reader.py b/unit_trace/trace_reader.py
index 44a3c75..e1d2095 100644
--- a/unit_trace/trace_reader.py
+++ b/unit_trace/trace_reader.py
@@ -5,7 +5,7 @@
 # trace_reader(files) returns an iterator which produces records
 # in order from the files given. (the param is a list of files.)
 #
-# Each record is just a Python object. It is guaranteed to have the following 
+# Each record is just a Python object. It is guaranteed to have the following
 # attributes:
 #   - 'pid': pid of the task
 #   - 'job': job number for that task
@@ -66,7 +66,7 @@ def trace_reader(files):
    # overwhelmingly probably.
    for x in range(0,len(file_iter_buff)):
        for y in range(0,100):
-            file_iter_buff[x].append(file_iters[x].next()) 
+            file_iter_buff[x].append(file_iters[x].next())
    for x in range(0,len(file_iter_buff)):
        file_iter_buff[x] = sorted(file_iter_buff[x],key=lambda rec: rec.when)
@@ -110,7 +110,7 @@ def trace_reader(files):
            last_time = earliest.when
        # Yield the record
-        yield earliest 
+        yield earliest
 ###############################################################################
 # Private functions
@@ -123,11 +123,11 @@ def _get_file_iter(file):
        data = f.read(RECORD_HEAD_SIZE)
        try:
            type_num = struct.unpack_from('b',data)[0]
-        except struct.error: 
+        except struct.error:
            break #We read to the end of the file
        type = _get_type(type_num)
        try:
-            values = struct.unpack_from(StHeader.format + 
+            values = struct.unpack_from(StHeader.format +
                type.format,data)
            record_dict = dict(zip(type.keys,values))
        except struct.error:
@@ -157,7 +157,7 @@ def _dict2obj(d):
    o = Obj()
    for key in d.keys():
        o.__dict__[key] = d[key]
-    return o 
+    return o
 ###############################################################################
 # Trace record data types and accessor functions
@@ -183,7 +183,7 @@ class StNameData:
    keys = StHeader.keys + ['name']
    message = 'The name of the executable of this process.'
-class StParamData:  
+class StParamData:
    format =  'IIIc'
    formatStr = struct.Struct(StHeader.format + format)
    keys = StHeader.keys + ['wcet','period','phase','partition']
@@ -195,7 +195,7 @@ class StReleaseData:
    keys = StHeader.keys + ['when','deadline']
    message = 'A job was/is going to be released.'
-#Not yet used by Sched Trace 
+#Not yet used by Sched Trace
 class StAssignedData:
    format =  'Qc'
    formatStr = struct.Struct(StHeader.format + format)
diff --git a/unit_trace/viz/convert.py b/unit_trace/viz/convert.py
index a7aff8b..d19bc73 100644
--- a/unit_trace/viz/convert.py
+++ b/unit_trace/viz/convert.py
@@ -24,13 +24,13 @@ def _get_job_from_record(sched, record):
        sched.get_tasks()[tname].add_job(Job(job_no, []))
    job = sched.get_tasks()[tname].get_jobs()[job_no]
    return job
-    
 def convert_trace_to_schedule(stream):
    """The main function of interest in this module. Coverts a stream of records
    to a Schedule object."""
    def noop():
        pass
-            
    num_cpus, stream = _find_num_cpus(stream)
    sched = Schedule('sched', num_cpus)
    for record in stream:
@@ -41,10 +41,10 @@ def convert_trace_to_schedule(stream):
        if record.record_type == 'event':
            job = _get_job_from_record(sched, record)
            cpu = record.cpu
-        
            if not hasattr(record, 'deadline'):
                record.deadline = None
-                
            actions = {
                'name' : (noop),
                'params' : (noop),
@@ -64,27 +64,27 @@ def convert_trace_to_schedule(stream):
                job.add_event(ResumeEvent(record.when, cpu))),
                'sys_release' : (noop)
            }
-        
            actions[record.type_name]()
-    
        elif record.record_type == 'error':
            job = _get_job_from_record(sched, record.job)
-            
            actions = {
                'inversion_start' : (lambda :
                job.add_event(InversionStartEvent(record.job.inversion_start))),
                'inversion_end' : (lambda :
                job.add_event(InversionEndEvent(record.job.inversion_end)))
            }
-        
            actions[record.type_name]()
-    
    return sched
-    
 def _pid_to_task_name(pid):
    """Converts a PID to an appropriate name for a task."""
    return str(pid)
-          
 def _find_num_cpus(stream):
    """Determines the number of CPUs used by scanning the binary format."""
    max = 0
@@ -94,7 +94,7 @@ def _find_num_cpus(stream):
        if record.record_type == 'event':
            if record.cpu > max:
                max = record.cpu
-    
    def recycle(l):
        for record in l:
            yield record
diff --git a/unit_trace/viz/draw.py b/unit_trace/viz/draw.py
index 8c48744..dced27d 100644
--- a/unit_trace/viz/draw.py
+++ b/unit_trace/viz/draw.py
@@ -27,19 +27,19 @@ class Surface(object):
        self.height = 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 might actually represent just a ``window'' into
        what we are drawing on. For instance, if we are scrolling through
@@ -51,7 +51,7 @@ class Surface(object):
        self.virt_y = y
        self.width = width
        self.height = height
-        
    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
@@ -59,48 +59,48 @@ class Surface(object):
        bounds of the surface,
        if we want something outside the surface's ``window''."""
        return (x - self.virt_x, y - 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])
@@ -114,89 +114,89 @@ 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 scaled(self, *coors):
        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, \
@@ -204,31 +204,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
@@ -241,48 +241,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.
@@ -291,22 +291,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)
@@ -315,7 +315,7 @@ class Canvas(object):
            for i in range(start_tick, end_tick + 1):
                self.draw_line((x, y), (x, y + line_height), GraphFormat.GRID_COLOR, GraphFormat.GRID_THICKNESS)
                x += maj_sep
-    
    def _draw_bar_border_common(self, x, y, width, height, color, thickness, clip_side):
        if clip_side is None:
            self.draw_rect(x, y, width, height, color, thickness)
@@ -325,213 +325,213 @@ class Canvas(object):
        elif clip_side == AlignMode.RIGHT:
            self.draw_polyline([(x + width, y), (x, y), (x, y + height), (x + width, y + height)],
                                 color, thickness)
-                                 
    def draw_bar(self, x, y, width, height, n, clip_side, selected):
        """Draws a bar with a certain set of dimensions, using pattern ``n'' from the
        bar pattern list."""
-        
        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_bar_border_common(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_bar_border_common(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, real_x, real_y, width, height):
        x = real_x + self.surface.virt_x
        y = real_y + self.surface.virt_y
        for event in self.selectable_regions.keys():
            if self.selectable_regions[event].intersects(x, y, width, height):
                del self.selectable_regions[event]
-        
    def add_sel_region(self, region):
        self.selectable_regions[region.get_event()] = region
-    
    def get_sel_region(self, event):
        return self.selectable_regions[event]
-            
    def get_selected_regions(self, real_x, real_y, width, height):
        x = real_x + self.surface.virt_x
        y = real_y + self.surface.virt_y
-    
        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, real_x, real_y, width, height):
        """Overwrites the surface completely white, but technically doesn't delete anything"""
        self.fill_rect(self.surface.virt_x + real_x, self.surface.virt_y + real_y, width,
                       height, (1.0, 1.0, 1.0), 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
@@ -545,30 +545,30 @@ 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, do_snap=True):
        x, y, width, height = self.scaled(x, y, width, height)
        x, y = self.surface.get_real_coor(x, y)
@@ -576,23 +576,23 @@ class CairoCanvas(Canvas):
            self.surface.ctx.rectangle(snap(x), snap(y), width, height)
        else:
            self.surface.ctx.rectangle(x, y, width, height)
-            
        self.surface.ctx.set_line_width(thickness * self.scale)
        self.surface.ctx.set_source_rgb(color[0], color[1], color[2])
-        
    def draw_rect(self, x, y, width, height, color, thickness, do_snap=True):
        self._rect_common(x, y, width, height, color, thickness, do_snap)
        self.surface.ctx.stroke()
-    
    def fill_rect(self, x, y, width, height, color, 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))
@@ -607,7 +607,7 @@ class CairoCanvas(Canvas):
        else:
            self.surface.ctx.rectangle(snap(x), snap(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])
@@ -617,34 +617,34 @@ 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):
        real_coor_list = [self.surface.get_real_coor(coor[0], coor[1]) for coor in coor_list]
        self.surface.ctx.move_to(real_coor_list[0][0], real_coor_list[0][1])
        if do_snap:
            for i in range(0, len(real_coor_list)):
                real_coor_list[i] = (snap(real_coor_list[i][0]), snap(real_coor_list[i][1]))
-                
        for coor in real_coor_list[1:]:
            self.surface.ctx.line_to(coor[0], coor[1])
-        
-        self.surface.ctx.set_line_width(thickness)    
+        self.surface.ctx.set_line_width(thickness)
        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,
@@ -652,30 +652,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)
-        
        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
@@ -685,21 +685,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)
@@ -719,7 +719,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):
@@ -728,23 +728,23 @@ class SelectableRegion(object):
        self.width = width
        self.height = height
        self.event = event
-    
    def get_dimensions(self):
        return (self.x, self.y, self.width, self.height)
-        
    def get_event(self):
        return self.event
-    
    def intersects(self, x, y, width, height):
        return x <= self.x + self.width and x + width >= self.x and y <= self.y + self.height and y + height >= self.y
-        
 class Graph(object):
    DEF_BAR_PLIST = [Pattern([(0.0, 0.9, 0.9)]), Pattern([(0.9, 0.3, 0.0)]), Pattern([(0.9, 0.7, 0.0)]),
                     Pattern([(0.0, 0.0, 0.8)]), Pattern([(0.0, 0.2, 0.9)]), Pattern([(0.0, 0.6, 0.6)]),
                     Pattern([(0.75, 0.75, 0.75)])]
    DEF_ITEM_CLIST = [(0.3, 0.0, 0.0), (0.0, 0.3, 0.0), (0.0, 0.0, 0.3), (0.3, 0.3, 0.0), (0.0, 0.3, 0.3),
                      (0.3, 0.0, 0.3)]
-    
    def __init__(self, CanvasType, surface, start_time, end_time, y_item_list, attrs=GraphFormat(),
                 item_clist=DEF_ITEM_CLIST, bar_plist=DEF_BAR_PLIST):
        # deal with possibly blank schedules
@@ -752,16 +752,16 @@ class Graph(object):
            start_time = 0
        if end_time is None:
            end_time = 0
-         
        if start_time > end_time:
            raise ValueError("Litmus is not a time machine")
-            
        self.attrs = attrs
        self.start_time = start_time
        self.end_time = end_time
        self.y_item_list = y_item_list
        self.num_maj = int(math.ceil((self.end_time - self.start_time) * 1.0 / self.attrs.time_per_maj)) + 1
-    
        width = self.num_maj * self.attrs.maj_sep + GraphFormat.X_AXIS_MEASURE_OFS + GraphFormat.WIDTH_PAD
        height = (len(self.y_item_list) + 1) * self.attrs.y_item_size + GraphFormat.HEIGHT_PAD
@@ -771,7 +771,7 @@ class Graph(object):
        extra_width = 0.0
        dummy_surface = surface.__class__()
        dummy_surface.renew(10, 10)
-        
        dummy_surface.ctx.select_font_face(self.attrs.item_fopts.name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
        dummy_surface.ctx.set_font_size(self.attrs.item_fopts.size)
        for item in self.y_item_list:
@@ -780,45 +780,45 @@ class Graph(object):
            cur_width = te[2]
            if cur_width > extra_width:
                extra_width = cur_width
-            
        width += extra_width
-        
        self.origin = (extra_width + GraphFormat.WIDTH_PAD / 2.0, height - GraphFormat.HEIGHT_PAD / 2.0)
-        
        self.width = width
        self.height = height
-        
        #if surface.ctx is None:
        #    surface.renew(width, height)
-        
        self.canvas = CanvasType(width, height, item_clist, bar_plist, surface)
-    
    def get_selected_regions(self, real_x, real_y, width, height):
        return self.canvas.get_selected_regions(real_x, real_y, width, height)
-                
    def get_width(self):
        return self.width
-        
    def get_height(self):
        return self.height
-    
    def get_origin(self):
        return self.origin
-        
    def get_attrs(self):
        return self.attrs
-    
    def add_sel_region(self, region):
        self.canvas.add_sel_region(region)
-    
    def get_sel_region(self, event):
        return self.canvas.get_sel_region(event)
-        
    def update_view(self, x, y, width, height, ctx):
        """Proxy into the surface's pan."""
        self.canvas.surface.pan(x, y, width, height)
        self.canvas.surface.change_ctx(ctx)
-    
    def _recomp_min_max(self, start_time, end_time, start_item, end_item):
        if self.min_time is None or start_time < self.min_time:
            self.min_time = start_time
@@ -828,79 +828,79 @@ class Graph(object):
            self.min_item = start_item
        if self.max_item is None or end_item > self.max_item:
            self.max_item = end_item
-        
    def _get_time_xpos(self, time):
        """get x so that x is at instant ``time'' on the graph"""
        return self.origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + 1.0 * (time - self.start_time) / self.attrs.time_per_maj * self.attrs.maj_sep
-    
    def _get_item_ypos(self, item_no):
        """get y so that y is where the top of a bar would be in item #n's area"""
-        return self.origin[1] - self._get_y_axis_height() + self.attrs.y_item_size * (item_no + 0.5 - GraphFormat.BAR_SIZE_FACTOR / 2.0)     
+        return self.origin[1] - self._get_y_axis_height() + self.attrs.y_item_size * (item_no + 0.5 - GraphFormat.BAR_SIZE_FACTOR / 2.0)
-    
    def _get_bar_width(self, start_time, end_time):
        return 1.0 * (end_time - start_time) / self.attrs.time_per_maj * self.attrs.maj_sep
-    
    def _get_bar_height(self):
        return self.attrs.y_item_size * GraphFormat.BAR_SIZE_FACTOR
-    
    def _get_mini_bar_height(self):
        return self.attrs.y_item_size * GraphFormat.MINI_BAR_SIZE_FACTOR
-        
    def _get_mini_bar_ofs(self):
        return self.attrs.y_item_size * (GraphFormat.MINI_BAR_SIZE_FACTOR + GraphFormat.BAR_MINI_BAR_GAP_FACTOR)
-        
    def _get_y_axis_height(self):
        return (len(self.y_item_list) + 1) * self.attrs.y_item_size
-    
    def _get_bottom_tick(self, time):
        return int(math.floor((time - self.start_time) / self.attrs.time_per_maj))
-    
    def _get_top_tick(self, time):
        return int(math.ceil((time - self.start_time) / self.attrs.time_per_maj))
-        
    def get_surface(self):
        """Gets the underlying surface."""
        return self.canvas.get_surface()
-    
    def xcoor_to_time(self, x):
        #x = self.origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + (time - self.start) / self.attrs.time_per_maj * self.attrs.maj_sep
        return (x - self.origin[0] - GraphFormat.X_AXIS_MEASURE_OFS) / self.attrs.maj_sep \
                * self.attrs.time_per_maj + self.start_time
-    
    def ycoor_to_item_no(self, y):
-        return int((y - self.origin[1] + self._get_y_axis_height()) // self.attrs.y_item_size) 
+        return int((y - self.origin[1] + self._get_y_axis_height()) // self.attrs.y_item_size)
-    
    def get_offset_params(self, real_x, real_y, width, height):
        start_time = self.xcoor_to_time(self.canvas.surface.virt_x + real_x)
        end_time = self.xcoor_to_time(self.canvas.surface.virt_x + real_x + width)
-        
        start_item = self.ycoor_to_item_no(self.canvas.surface.virt_y + real_y)
        end_item = 2 + self.ycoor_to_item_no(self.canvas.surface.virt_y + real_y + height)
-        
        return (start_time, end_time, start_item, end_item)
-    
    def draw_skeleton(self, start_time, end_time, start_item, end_item):
        self.draw_grid_at_time(start_time, end_time, start_item, end_item)
        self.draw_x_axis_with_labels_at_time(start_time, end_time)
        self.draw_y_axis_with_labels()
-            
    def render_surface(self, sched, regions, selectable=False):
        raise NotImplementedError
-    
    def render_all(self, schedule):
        raise NotImplementedError
-    
    def render_events(self, event_list):
        for layer in Canvas.LAYERS:
            prev_events = {}
            for event in event_list:
                event.render(self, layer, prev_events)
-                        
    def draw_axes(self, x_axis_label, y_axis_label):
        """Draws and labels the axes according to the parameters that we were initialized
-        with."""    
+        with."""
        self.draw_grid_at_time(self.start_time, self.end_time, 0, len(self.attrs.y_item_list) - 1)
-        
        self.canvas.draw_x_axis(self.origin[0], self.origin[1], self.num_maj, self.attrs.maj_sep, self.attrs.min_per_maj)
        self.canvas.draw_y_axis(self.origin[0], self.origin[1], self._get_y_axis_height())
        self.canvas.draw_x_axis_labels(self.origin[0], self.origin[1], 0, self.num_maj - 1,\
@@ -908,274 +908,274 @@ class Graph(object):
                                self.attrs.time_per_maj, self.attrs.show_min, self.attrs.majfopts, self.attrs.minfopts)
        self.canvas.draw_y_axis_labels(self.origin[0], self.origin[1], self._get_y_axis_height(), self.y_item_list, \
                                       self.attrs.y_item_size, self.attrs.item_fopts)
-    
    def draw_grid_at_time(self, start_time, end_time, start_item, end_item):
        """Draws the grid, but only in a certain time and item range."""
        start_tick = max(0, self._get_bottom_tick(start_time))
        end_tick = min(self.num_maj - 1, self._get_top_tick(end_time))
-        
        start_item = max(0, start_item)
        end_item = min(len(self.y_item_list), end_item)
-        
        self.canvas.draw_grid(self.origin[0], self.origin[1], self._get_y_axis_height(),
                              start_tick, end_tick, start_item, end_item, self.attrs.maj_sep, self.attrs.y_item_size, \
                              self.attrs.min_per_maj, True)
-    
    def draw_x_axis_with_labels_at_time(self, start_time, end_time):
        start_tick = max(0, self._get_bottom_tick(start_time))
        end_tick = min(self.num_maj - 1, self._get_top_tick(end_time))
-                                      
        self.canvas.draw_x_axis(self.origin[0], self.origin[1], start_tick, end_tick, \
                                self.attrs.maj_sep, self.attrs.min_per_maj)
        self.canvas.draw_x_axis_labels(self.origin[0], self.origin[1], start_tick, \
                                end_tick, self.attrs.maj_sep, self.attrs.min_per_maj,
                                self.start_time + start_tick * self.attrs.time_per_maj,
                                self.attrs.time_per_maj, False)
-                                
    def draw_y_axis_with_labels(self):
        self.canvas.draw_y_axis(self.origin[0], self.origin[1], self._get_y_axis_height())
        self.canvas.draw_y_axis_labels(self.origin[0], self.origin[1], self._get_y_axis_height(), \
                                       self.y_item_list, self.attrs.y_item_size)
-            
    def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
        """Draws a suspension symbol for a certain task at an instant in time."""
        raise NotImplementedError
-    
    def add_sel_suspend_triangle_at_time(self, time, task_no, cpu_no, event):
        """Same as above, except instead of drawing adds a selectable region at
        a certain time."""
        raise NotImplementedError
-    
    def draw_resume_triangle_at_time(self, time, task_no, cpu_no, selected=False):
        """Draws a resumption symbol for a certain task at an instant in time."""
        raise NotImplementedError
-    
    def add_sel_resume_triangle_at_time(self, time, task_no, cpu_no, event):
        """Same as above, except instead of drawing adds a selectable region at
        a certain time."""
        raise NotImplementedError
-            
    def draw_completion_marker_at_time(self, time, task_no, cpu_no, selected=False):
        """Draws a completion marker for a certain task at an instant in time."""
        raise NotImplementedError
-    
    def add_sel_completion_marker_at_time(self, time, task_no, cpu_no, event):
        """Same as above, except instead of drawing adds a selectable region at
        a certain time."""
        raise NotImplementedError
-            
    def draw_release_arrow_at_time(self, time, task_no, job_no, selected=False):
        """Draws a release arrow at a certain time for some task and job"""
        raise NotImplementedError
-    
    def add_sel_release_arrow_at_time(self, time, task_no, event):
        """Same as above, except instead of drawing adds a selectable region at
        a certain time."""
        raise NotImplementedError
-            
    def draw_deadline_arrow_at_time(self, time, task_no, job_no, selected=False):
        """Draws a deadline arrow at a certain time for some task and job"""
        raise NotImplementedError
-    
    def add_sel_deadline_arrow_at_time(self, time, task_no, event):
        """Same as above, except instead of drawing adds a selectable region at
        a certain time."""
        raise NotImplementedError
-        
    def draw_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None):
        """Draws a bar over a certain time period for some task, optionally labelling it."""
        raise NotImplementedError
-        
    def add_sel_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
        """Same as above, except instead of drawing adds a selectable region at
        a certain time."""
        raise NotImplementedError
-    
    def draw_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, clip_side=None, job_no=None):
        """Draws a mini bar over a certain time period for some task, optionally labelling it."""
        raise NotImplementedError
-        
    def add_sel_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
        """Same as above, except instead of drawing adds a selectable region at
        a certain time."""
        raise NotImplementedError
-            
 class TaskGraph(Graph):
    def render_surface(self, sched, regions, selectable=False):
        events_to_render = {}
        for layer in Canvas.LAYERS:
            events_to_render[layer] = {}
-        
        for region in regions:
            x, y, width, height = region
            if not selectable:
                self.canvas.whiteout(x, y, width, height)
            else:
                self.canvas.clear_selectable_regions(x, y, width, height)
-        
-        self.min_time, self.max_time, self.min_item, self.max_item = None, None, None, None  
+        self.min_time, self.max_time, self.min_item, self.max_item = None, None, None, None
        for region in regions:
            x, y, width, height = region
            start_time, end_time, start_item, end_item = self.get_offset_params(x, y, width, height)
            self._recomp_min_max(start_time, end_time, start_item, end_item)
-            
            for event in sched.get_time_slot_array().iter_over_period(
                        start_time, end_time, start_item, end_item,
                        schedule.TimeSlotArray.TASK_LIST, schedule.EVENT_LIST):
                events_to_render[event.get_layer()][event] = None
-        
        if not selectable:
            self.draw_skeleton(self.min_time, self.max_time,
                               self.min_item, self.max_item)
-        
        #if not selectable:
        #    for layer in events_to_render:
        #        print 'task render on layer', layer, ':', [str(e) for e in events_to_render[layer].keys()]
-            
        for layer in Canvas.LAYERS:
            prev_events = {}
            for event in events_to_render[layer]:
                event.render(self, layer, prev_events, selectable)
-        
    def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
        height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
        self.canvas.draw_suspend_triangle(x, y, height, selected)
-    
    def add_sel_suspend_triangle_at_time(self, time, task_no, cpu_no, event):
        height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
        self.canvas.add_sel_suspend_triangle(x, y, height, event)
-        
    def draw_resume_triangle_at_time(self, time, task_no, cpu_no, selected=False):
        height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
        self.canvas.draw_resume_triangle(x, y, height, selected)
-    
    def add_sel_resume_triangle_at_time(self, time, task_no, cpu_no, event):
        height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
        self.canvas.add_sel_resume_triangle(x, y, height, event)
-        
    def draw_completion_marker_at_time(self, time, task_no, cpu_no, selected=False):
        height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
        self.canvas.draw_completion_marker(x, y, height, selected)
-    
    def add_sel_completion_marker_at_time(self, time, task_no, cpu_no, event):
        height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
-        
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
        self.canvas.add_sel_completion_marker(x, y, height, event)
-            
    def draw_release_arrow_at_time(self, time, task_no, job_no=None, selected=False):
        height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
        self.canvas.draw_release_arrow_big(x, y, height, selected)
-    
    def add_sel_release_arrow_at_time(self, time, task_no, event):
        height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
        self.canvas.add_sel_release_arrow_big(x, y, height, event)
-        
    def draw_deadline_arrow_at_time(self, time, task_no, job_no=None, selected=False):
        height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(task_no)
-        
        self.canvas.draw_deadline_arrow_big(x, y, height, selected)
-    
    def add_sel_deadline_arrow_at_time(self, time, task_no, event):
        height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(task_no)
-        
        self.canvas.add_sel_deadline_arrow_big(x, y, height, event)
-        
    def draw_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
        if start_time > end_time:
            raise ValueError("Litmus is not a time machine")
-            
        x = self._get_time_xpos(start_time)
        y = self._get_item_ypos(task_no)
        width = self._get_bar_width(start_time, end_time)
        height = self._get_bar_height()
-        
        self.canvas.draw_bar(x, y, width, height, cpu_no, clip_side, selected)
-        
        # if a job number is specified, we want to draw a superscript and subscript for the task and job number, respectively
        if job_no is not None:
            x += GraphFormat.BAR_LABEL_OFS
            y += self.attrs.y_item_size * GraphFormat.BAR_SIZE_FACTOR / 2.0
            self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                GraphFormat.DEF_FOPTS_BAR, GraphFormat.DEF_FOPTS_BAR_SSCRIPT, AlignMode.LEFT, AlignMode.CENTER)
-    
    def add_sel_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
        if start_time > end_time:
            raise ValueError("Litmus is not a time machine")
-            
        x = self._get_time_xpos(start_time)
        y = self._get_item_ypos(task_no)
        width = self._get_bar_width(start_time, end_time)
        height = self._get_bar_height()
-        
        self.canvas.add_sel_bar(x, y, width, height, event)
-    
    def draw_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
        if start_time > end_time:
            raise ValueError("Litmus is not a time machine")
-            
        x = self._get_time_xpos(start_time)
        y = self._get_item_ypos(task_no) - self._get_mini_bar_ofs()
        width = self._get_bar_width(start_time, end_time)
        height = self._get_mini_bar_height()
-        
        self.canvas.draw_mini_bar(x, y, width, height, Canvas.NULL_PATTERN, clip_side, selected)
-        
        if job_no is not None:
            x += GraphFormat.MINI_BAR_LABEL_OFS
            y += self.attrs.y_item_size * GraphFormat.MINI_BAR_SIZE_FACTOR / 2.0
            self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                GraphFormat.DEF_FOPTS_MINI_BAR, GraphFormat.DEF_FOPTS_MINI_BAR_SSCRIPT, AlignMode.LEFT, AlignMode.CENTER)
-                
    def add_sel_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
        x = self._get_time_xpos(start_time)
        y = self._get_item_ypos(task_no) - self._get_mini_bar_ofs()
        width = self._get_bar_width(start_time, end_time)
        height = self._get_mini_bar_height()
-        
        self.canvas.add_sel_mini_bar(x, y, width, height, event)
-        
 class CpuGraph(Graph):
    def render_surface(self, sched, regions, selectable=False):
        BOTTOM_EVENTS = [schedule.ReleaseEvent, schedule.DeadlineEvent, schedule.InversionStartEvent,
                     schedule.InversionEndEvent, schedule.InversionDummy]
        TOP_EVENTS = [schedule.SuspendEvent, schedule.ResumeEvent, schedule.CompleteEvent,
                  schedule.SwitchAwayEvent, schedule.SwitchToEvent, schedule.IsRunningDummy]
-                  
        events_to_render = {}
        for layer in Canvas.LAYERS:
            events_to_render[layer] = {}
-        
        self.min_time, self.max_time, self.min_item, self.max_item = None, None, None, None
        for region in regions:
            x, y, width, height = region
@@ -1184,18 +1184,18 @@ class CpuGraph(Graph):
                self.canvas.whiteout(0, 0, self.canvas.surface.width, self.canvas.surface.height)
            else:
                self.canvas.clear_selectable_regions(x, y, width, height)
-        
        for region in regions:
            x, y, width, height = region
            start_time, end_time, start_item, end_item = self.get_offset_params(x, y, width, height)
            self._recomp_min_max(start_time, end_time, start_item, end_item)
-            
            for event in sched.get_time_slot_array().iter_over_period(
                        start_time, end_time, start_item, end_item,
                        schedule.TimeSlotArray.CPU_LIST,
                        TOP_EVENTS):
                events_to_render[event.get_layer()][event] = None
-        
            if end_item >= len(self.y_item_list):
                # we are far down enough that we should render the releases and deadlines and inversions,
                # which appear near the x-axis
@@ -1205,136 +1205,136 @@ class CpuGraph(Graph):
                        schedule.TimeSlotArray.CPU_LIST,
                        BOTTOM_EVENTS):
                    events_to_render[event.get_layer()][event] = None
-        
        if not selectable:
            self.draw_skeleton(self.min_time, self.max_time,
                               self.min_item, self.max_item)
-                                           
        for layer in Canvas.LAYERS:
            prev_events = {}
            for event in events_to_render[layer]:
                event.render(self, layer, prev_events, selectable)
-                
    def render(self, schedule, start_time=None, end_time=None):
        if end_time < start_time:
            raise ValueError('start must be less than end')
-            
        if start_time is None:
            start_time = self.start
        if end_time is None:
            end_time = self.end
        start_slot = self.get_time_slot(start_time)
        end_slot = min(len(self.time_slots), self.get_time_slot(end_time) + 1)
-        
        for layer in Canvas.LAYERS:
            prev_events = {}
            for i in range(start_slot, end_slot):
                for event in self.time_slots[i]:
                    event.render(graph, layer, prev_events)
-                    
    def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
        height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
        self.canvas.draw_suspend_triangle(x, y, height, selected)
-    
    def add_sel_suspend_triangle_at_time(self, time, task_no, cpu_no, event):
        height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
        self.canvas.add_sel_suspend_triangle(x, y, height, event)
-        
    def draw_resume_triangle_at_time(self, time, task_no, cpu_no, selected=False):
        height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
        self.canvas.draw_resume_triangle(x, y, height, selected)
-    
    def add_sel_resume_triangle_at_time(self, time, task_no, cpu_no, event):
        height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
        self.canvas.add_sel_resume_triangle(x, y, height, event)
-        
    def draw_completion_marker_at_time(self, time, task_no, cpu_no, selected=False):
        height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(cpu_no) + self._get_bar_height() - height
-        
        self.canvas.draw_completion_marker(x, y, height, selected)
-    
    def add_sel_completion_marker_at_time(self, time, task_no, cpu_no, event):
        height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
-        
        x = self._get_time_xpos(time)
        y = self._get_item_ypos(cpu_no) + self._get_bar_height() - height
-        
        self.canvas.add_sel_completion_marker(x, y, height, event)
-            
    def draw_release_arrow_at_time(self, time, task_no, job_no=None, selected=False):
        if job_no is None and task_no is not None:
            raise ValueError("Must specify a job number along with the task number")
-            
        height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
        x = self._get_time_xpos(time)
        y = self.origin[1] - height
-        
        self.canvas.draw_release_arrow_small(x, y, height, selected)
-    
        if task_no is not None:
            y -= GraphFormat.ARROW_LABEL_OFS
            self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                                          GraphFormat.DEF_FOPTS_ARROW, GraphFormat.DEF_FOPTS_ARROW_SSCRIPT, \
                                          AlignMode.CENTER, AlignMode.BOTTOM)
-    
    def add_sel_release_arrow_at_time(self, time, task_no, event):
        height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
        x = self._get_time_xpos(time)
        y = self.origin[1] - height
-        
        self.canvas.add_sel_release_arrow_small(x, y, height, event)
-            
    def draw_deadline_arrow_at_time(self, time, task_no, job_no=None, selected=False):
        if job_no is None and task_no is not None:
            raise ValueError("Must specify a job number along with the task number")
-            
        height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
        x = self._get_time_xpos(time)
        y = self.origin[1] - height
-        
        self.canvas.draw_deadline_arrow_small(x, y, height, selected)
-    
        if task_no is not None:
            y -= GraphFormat.ARROW_LABEL_OFS
            self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                                          GraphFormat.DEF_FOPTS_ARROW, GraphFormat.DEF_FOPTS_ARROW_SSCRIPT, \
                                          AlignMode.CENTER, AlignMode.BOTTOM)
-    
    def add_sel_deadline_arrow_at_time(self, time, task_no, event):
        height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
        x = self._get_time_xpos(time)
        y = self.origin[1] - height
-        
        self.canvas.add_sel_deadline_arrow_small(x, y, height, event)
-        
    def draw_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
        if start_time > end_time:
            raise ValueError("Litmus is not a time machine")
-            
        x = self._get_time_xpos(start_time)
        y = self._get_item_ypos(cpu_no)
        width = self._get_bar_width(start_time, end_time)
        height = self._get_bar_height()
-        
        self.canvas.draw_bar(x, y, width, height, task_no, clip_side, selected)
-        
        # if a job number is specified, we want to draw a superscript and subscript for the task and job number, respectively
        if job_no is not None:
            x += GraphFormat.BAR_LABEL_OFS
@@ -1342,36 +1342,36 @@ class CpuGraph(Graph):
            self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                                                 GraphFormat.DEF_FOPTS_BAR, GraphFormat.DEF_FOPTS_BAR_SSCRIPT, \
                                                 AlignMode.LEFT, AlignMode.CENTER)
-    
    def add_sel_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
        x = self._get_time_xpos(start_time)
        y = self._get_item_ypos(cpu_no)
        width = self._get_bar_width(start_time, end_time)
        height = self._get_bar_height()
-        
        self.canvas.add_sel_bar(x, y, width, height, event)
-    
    def draw_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
        if start_time > end_time:
            raise ValueError("Litmus is not a time machine")
-            
        x = self._get_time_xpos(start_time)
        y = self._get_item_ypos(len(self.y_item_list))
        width = self._get_bar_width(start_time, end_time)
        height = self._get_mini_bar_height()
-        
        self.canvas.draw_mini_bar(x, y, width, height, task_no, clip_side, selected)
-        
        if job_no is not None:
            x += GraphFormat.MINI_BAR_LABEL_OFS
            y += self.attrs.y_item_size * GraphFormat.MINI_BAR_SIZE_FACTOR / 2.0
            self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                GraphFormat.DEF_FOPTS_MINI_BAR, GraphFormat.DEF_FOPTS_MINI_BAR_SSCRIPT, AlignMode.LEFT, AlignMode.CENTER)
-                
    def add_sel_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
        x = self._get_time_xpos(start_time)
        y = self._get_item_ypos(len(self.y_item_list))
        width = self._get_bar_width(start_time, end_time)
        height = self._get_mini_bar_height()
-        
        self.canvas.add_sel_mini_bar(x, y, width, height, event)
diff --git a/unit_trace/viz/format.py b/unit_trace/viz/format.py
index 33e0b03..c544e26 100644
--- a/unit_trace/viz/format.py
+++ b/unit_trace/viz/format.py
@@ -13,41 +13,41 @@ class AlignMode(object):
    LEFT = 0
    CENTER = 1
    RIGHT = 2
-    
    BOTTOM = 3
    TOP = 4
-        
 class GraphFormat(object):
    """Container class for a bunch of optional and non-optional attributes to configure the appearance of the graph
    (because it would be annoying to just have these all as raw arguments to the Graph constructor, and many people
    probably don't care about most of them anyway)."""
-    
    GRID_COLOR = (0.7, 0.7, 0.7)
    HIGHLIGHT_COLOR = (0.85, 0.0, 0.0)
    BORDER_COLOR = (0.0, 0.0, 0.0)
    LITE_BORDER_COLOR = (0.4, 0.4, 0.4)
-    
    BORDER_THICKNESS = 1
    GRID_THICKNESS = 1
    AXIS_THICKNESS = 1
-    
    BAND_THICKNESS = 1.5
    BAND_COLOR = (0.85, 0.0, 0.0)
-    
    X_AXIS_MEASURE_OFS = 30
    X_AXIS_LABEL_GAP = 10
    Y_AXIS_ITEM_GAP = 10
    MAJ_TICK_SIZE = 20
    MIN_TICK_SIZE = 12
-    
    BIG_ARROWHEAD_FACTOR = 0.2
    SMALL_ARROWHEAD_FACTOR = 0.3
    TEE_FACTOR = 0.3
-    
    DEF_FOPTS_LABEL = FontOptions("Times", 16, (0.0, 0.0, 0.0))
    DEF_FOPTS_LABEL_SSCRIPT = FontOptions("Times", 8, (0.0, 0.0, 0.0))
    DEF_FOPTS_MAJ = FontOptions("Times", 14, (0.1, 0.1, 0.1))
-    DEF_FOPTS_MIN = FontOptions("Times", 9, (0.1, 0.1, 0.1)) 
+    DEF_FOPTS_MIN = FontOptions("Times", 9, (0.1, 0.1, 0.1))
    DEF_FOPTS_ITEM = FontOptions("Times", 20, (0.0, 0.5, 0.1))
    DEF_FOPTS_BAR = FontOptions("Times", 14, (0.0, 0.0, 0.0))
    DEF_FOPTS_BAR_SSCRIPT = FontOptions("Times", 7, (0.0, 0.0, 0.0))
@@ -55,31 +55,31 @@ class GraphFormat(object):
    DEF_FOPTS_MINI_BAR_SSCRIPT = FontOptions("Times", 7, (0.0, 0.0, 0.0))
    DEF_FOPTS_ARROW = FontOptions("Times", 12, (0.0, 0.0, 0.0))
    DEF_FOPTS_ARROW_SSCRIPT = FontOptions("Times", 7, (0.0, 0.0, 0.0))
-    
    LEFT_SIDE_PAD = 30
    WIDTH_PAD = 50
    HEIGHT_PAD = 150
    Y_ITEM_PAD_FACTOR = 0.5
-    
    DEF_TIME_PER_MAJ = 10
    DEF_MAJ_SEP = 200
    DEF_MIN_PER_MAJ = 5
    DEF_Y_ITEM_SIZE = 50
-    
    AXIS_LABEL_VERT_OFS = 30
    BAR_SIZE_FACTOR = 0.4
    MINI_BAR_SIZE_FACTOR = 0.2
    BAR_MINI_BAR_GAP_FACTOR = 0.1
-                
    BAR_LABEL_OFS = 2
    MINI_BAR_LABEL_OFS = 1
    ARROW_LABEL_OFS = 2
-    
    BLOCK_TRIANGLE_FACTOR = 0.7
    BIG_ARROW_FACTOR = 1.6
    SMALL_ARROW_FACTOR = 0.6
    COMPLETION_MARKER_FACTOR = 1.6
-    
    def __init__(self, time_per_maj=DEF_TIME_PER_MAJ, maj_sep=DEF_MAJ_SEP, \
    min_per_maj=DEF_MIN_PER_MAJ, y_item_size=DEF_Y_ITEM_SIZE, bar_fopts=DEF_FOPTS_BAR, \
    item_fopts=DEF_FOPTS_ITEM, show_min=False, majfopts=DEF_FOPTS_MAJ, \
diff --git a/unit_trace/viz/renderer.py b/unit_trace/viz/renderer.py
index d94129c..46c6628 100644
--- a/unit_trace/viz/renderer.py
+++ b/unit_trace/viz/renderer.py
@@ -4,17 +4,17 @@ from draw import *
 """The renderer, a glue object which converts a schedule to its representation
 on a graph."""
-        
 class Renderer(object):
    def __init__(self, schedule):
        self.schedule = schedule
-    
    def prepare_task_graph(self, SurfaceType=ImageSurface, attrs=GraphFormat()):
        """Outputs the fully-rendered graph (y-axis = tasks) to a Cairo ImageSurface"""
        item_list = self.get_task_item_list()
        start, end = self.schedule.get_time_bounds()
        self.graph = TaskGraph(CairoCanvas, SurfaceType(), start, end, item_list, attrs)
-    
    def prepare_cpu_graph(self, SurfaceType=ImageSurface, attrs=GraphFormat()):
        item_list = ['CPU %d' % i for i in range(0, self.schedule.get_num_cpus())]
        start, end = self.schedule.get_time_bounds()
@@ -25,16 +25,16 @@ class Renderer(object):
        and drawing it piece by piece"""
        #graph.draw_axes('Time', '')
        self.schedule.render(self.graph)
-    
    def write_out(self, fname):
        self.graph.surface.write_out(fname)
-        
    def get_graph(self):
        return self.graph
-    
    def get_schedule(self):
        return self.schedule
-        
    def get_task_item_list(self):
        return [task.get_name() for task in self.schedule.get_task_list()]
-    
diff --git a/unit_trace/viz/schedule.py b/unit_trace/viz/schedule.py
index f134562..71f42ec 100644
--- a/unit_trace/viz/schedule.py
+++ b/unit_trace/viz/schedule.py
@@ -18,19 +18,19 @@ class TimeSlotArray(object):
    the (approximate) time at which they occur. Events that occur at approximately the same
    time are assigned the same ``slot'', and each slot organizes its events by task number
    as well as by CPU."""
-    
    TASK_LIST = 0
    CPU_LIST = 1
-    
    def __init__(self, time_per_maj=None, num_tasks=0, num_cpus=0):
        if time_per_maj is None:
            self.array = None
            return
-            
        self.time_per_maj = time_per_maj
        self.list_sizes = { TimeSlotArray.TASK_LIST : num_tasks, TimeSlotArray.CPU_LIST : num_cpus }
        self.array = {}
-        
        for type in self.list_sizes:
            num = self.list_sizes[type]
            self.array[type] = []
@@ -40,26 +40,26 @@ class TimeSlotArray(object):
                # by task).
                self.array[type].append(dict(zip(EVENT_LIST, \
                                [{} for j in range(0, len(EVENT_LIST))])))
-    
    def get_time_slot(self, time):
        return int(time // self.time_per_maj)
-    
    def _put_event_in_slot(self, list_type, no, klass, slot, event):
        if slot not in self.array[list_type][no][klass]:
            self.array[list_type][no][klass][slot] = []
        self.array[list_type][no][klass][slot].append(event)
-                
    def add_event_to_time_slot(self, event):
        task_no = event.get_job().get_task().get_task_no()
        cpu = event.get_cpu()
        time_slot = self.get_time_slot(event.get_time())
-        
        self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, event.__class__, time_slot, event)
        self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, event.__class__, time_slot, event)
-        
        if event.__class__ in SPAN_END_EVENTS:
            self.fill_span_event_from_end(event)
-        
    def fill_span_event_from_end(self, event):
        start_slot = None
        if event.corresp_start_event is None:
@@ -67,18 +67,18 @@ class TimeSlotArray(object):
        else:
            start_slot = self.get_time_slot(event.corresp_start_event.get_time())
        end_slot = self.get_time_slot(event.get_time())
-        
        for slot in range(start_slot + 1, end_slot):
            task_no = event.get_job().get_task().get_task_no()
            cpu = event.get_cpu()
-            
            dummy = SPAN_END_EVENTS[event.__class__](task_no, cpu)
            dummy.corresp_start_event = event.corresp_start_event
            dummy.corresp_end_event = event
-                    
            self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, dummy.__class__, slot, dummy)
            self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, dummy.__class__, slot, dummy)
-            
    def fill_span_event_from_start(self, event):
        end_slot = None
        if event.corresp_end_event is None:
@@ -86,44 +86,44 @@ class TimeSlotArray(object):
        else:
            end_slot = self.get_time_slot(event.corresp_end_event.get_time())
        start_slot = self.get_time_slot(event.get_time())
-        
        for slot in range(start_slot + 1, end_slot):
            task_no = event.get_job().get_task().get_task_no()
            cpu = event.get_cpu()
-            
            dummy = SPAN_START_EVENTS[event.__class__](task_no, cpu)
            dummy.corresp_start_event = event
            dummy.corresp_end_event = event.corresp_end_event
-            
            self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, dummy.__class__, slot, dummy)
            self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, dummy.__class__, slot, dummy)
-            
    def iter_over_period(self, start, end, start_no, end_no, list_type, event_types):
        if self.array is None:
            return # empty schedule
-            
        if start > end:
            raise ValueError('Litmus is not a time machine')
        if start_no > end_no:
            raise ValueError('start no should be less than end no')
-        
        start_slot = self.get_time_slot(start)
        end_slot = self.get_time_slot(end) + 2
-        
        start_no = max(0, start_no)
        end_no = min(self.list_sizes[list_type] - 1, end_no)
-        
        for no in range(start_no, end_no + 1):
            for type in event_types:
                for slot in range(start_slot, end_slot):
                    if slot in self.array[list_type][no][type]:
                        for event in self.array[list_type][no][type][slot]:
                            yield event
-    
 class Schedule(object):
    """The total schedule (task system), consisting of a certain number of
    tasks."""
-    
    def __init__(self, name, num_cpus, task_list=[]):
        self.name = name
        self.tasks = {}
@@ -134,41 +134,41 @@ class Schedule(object):
        self.num_cpus = num_cpus
        for task in task_list:
            self.add_task(task)
-    
    def get_selected(self):
        return self.selected
-        
    def set_selected(self, new_selected):
        for event in self.selected:
            event.selected = False
        for event in new_selected:
            event.selected = True
        self.selected = new_selected
-    
    def get_selected(self):
        return copy.copy(self.selected)
-            
    def set_time_params(self, time_per_maj=None):
        self.time_per_maj = time_per_maj
        if self.time_per_maj is None:
            self.time_slot_array = TimeSlotArray()
            return
-            
        self.time_slot_array = TimeSlotArray(self.time_per_maj, \
                                                 len(self.task_list), self.num_cpus)
-            
    def get_time_slot_array(self):
        return self.time_slot_array
-    
    def get_time_bounds(self):
        return (self.start, self.end)
-        
    def scan(self, time_per_maj):
        self.start = None
        self.end = None
-        
        self.set_time_params(time_per_maj)
-        
        # we scan the graph task by task, and job by job
        for task_no, task in enumerate(self.get_task_list()):
            switches = {}
@@ -176,12 +176,12 @@ class Schedule(object):
                switches[event] = None
            cur_cpu = [Event.NO_CPU]
            for job_no in sorted(task.get_jobs().keys()):
-                job = task.get_jobs()[job_no]    
+                job = task.get_jobs()[job_no]
                for event_time in sorted(job.get_events().keys()):
                    # could have multiple events at the same time (unlikely but possible)
                    for event in job.get_events()[event_time]:
                        event.scan(cur_cpu, switches)
-                        
            # What if one of the initial "span events" (switch to or inversion starting) never got a
            # corresponding end event? Well, then we assume that the end event was simply outside of
            # the range of whatever we read in. So we need to fill dummies starting from the initial
@@ -191,7 +191,7 @@ class Schedule(object):
                event = switches[span_event]
                if event is not None:
                    self.time_slot_array.fill_span_event_from_start(event)
-        
    def add_task(self, task):
        if task.name in self.tasks:
            raise ValueError("task already in list!")
@@ -200,23 +200,23 @@ class Schedule(object):
        task.schedule = self
        task.task_no = self.cur_task_no
        self.cur_task_no += 1
-    
    def get_tasks(self):
        return self.tasks
-        
    def get_task_list(self):
        return self.task_list
-    
    def get_name(self):
        return self.name
-    
    def get_num_cpus(self):
        return self.num_cpus
-                    
 class Task(object):
    """Represents a task, including the set of jobs that were run under
    this task."""
-    
    def __init__(self, name, job_list=[]):
        self.name = name
        self.jobs = {}
@@ -224,25 +224,25 @@ class Task(object):
        self.schedule = None
        for job in job_list:
            self.add_job(job)
-        
    def add_job(self, job):
        if job.job_no in self.jobs:
            raise ScheduleError("a job is already being released at this time for this task")
        self.jobs[job.job_no] = job
        job.task = self
-    
    def get_schedule(self):
        return self.schedule
-        
    def get_jobs(self):
        return self.jobs
-    
    def get_task_no(self):
        return self.task_no
-        
    def get_name(self):
        return self.name
-            
 class Job(object):
    """Represents a job, including everything that happens related to the job"""
    def __init__(self, job_no, event_list=[]):
@@ -251,19 +251,19 @@ class Job(object):
        self.task = None
        for event in event_list:
            self.add_event(event)
-        
    def add_event(self, event):
        if event.time not in self.events:
            self.events[event.time] = []
        self.events[event.time].append(event)
        event.job = self
-    
    def get_events(self):
        return self.events
-    
    def get_task(self):
        return self.task
-    
    def get_job_no(self):
        return self.job_no
@@ -279,61 +279,61 @@ class DummyEvent(object):
        self.cpu = cpu
        self.job = None
        self.layer = None
-    
    def __str__(self):
        return '[Dummy Event]'
-            
    def get_time(self):
        return self.time
-        
    def get_cpu(self):
        return self.cpu
-        
    def get_job(self):
        return self.job
-    
    def get_layer(self):
        return self.layer
-        
    def render(self, graph, layer, prev_events, selectable=False):
        """Method that the visualizer calls to tell the event to render itself
        Obviously only implemented by subclasses (actual event types)
-        
        ``Rendering'' can mean either actually drawing the event or just
        adding it as a selectable region. This is controlled by the
        ``selectable'' parameter"""
        raise NotImplementdError
-        
 class Event(DummyEvent):
    """Represents an event that occurs while a job is running (e.g. get scheduled
    on a CPU, block, ...)"""
    NO_CPU = -1
    NUM_DEC_PLACES = 2
-    
    def __init__(self, time, cpu):
        super(Event, self).__init__(time, cpu)
        self.erroneous = False
        self.selected = False
-    
    def __str__(self):
        return '[Event]'
-    
    def _common_str(self):
        job = self.get_job()
        task = job.get_task()
        return ' for task ' + str(task.get_name()) + ': (TASK, JOB)=' + str((task.get_task_no(), \
            job.get_job_no())) + ', CPU=' + str(self.get_cpu())
-            
    def is_erroneous(self):
        """An erroneous event is where something with the event is not quite right,
        something significantly wrong that we don't have logical information telling
        us how we should render the event."""
        return self.erroneous
-    
    def is_selected(self):
        """Returns whether the event has been selected by the user. (needed for rendering)"""
        return self.selected
-            
    def scan(self, cur_cpu, switches):
        """Part of the procedure that walks through all the events and sets
        some parameters that are unknown at first. For instance, a SwitchAwayEvent
@@ -348,26 +348,26 @@ class Event(DummyEvent):
            sched.start = time
        if sched.end is None or time > sched.end:
            sched.end = time
-        
        sched.get_time_slot_array().add_event_to_time_slot(self)
 class ErrorEvent(Event):
    pass
-                
 class SuspendEvent(Event):
    def __init__(self, time, cpu):
        super(SuspendEvent, self).__init__(time, cpu)
        self.layer = Canvas.MIDDLE_LAYER
-    
    def __str__(self):
        return 'Suspend' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
    def scan(self, cur_cpu, switches):
        if self.get_cpu() != cur_cpu[0]:
            self.erroneous = True
            #fprint "suspending on a CPU different from the CPU we are on!"
        super(SuspendEvent, self).scan(cur_cpu, switches)
-            
    def render(self, graph, layer, prev_events, selectable=False):
        if layer == self.layer:
            prev_events[self] = None
@@ -377,22 +377,22 @@ class SuspendEvent(Event):
            else:
                graph.draw_suspend_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                                self.get_cpu(), self.is_selected())
-            
-        
 class ResumeEvent(Event):
    def __init__(self, time, cpu):
        super(ResumeEvent, self).__init__(time, cpu)
        self.layer = Canvas.MIDDLE_LAYER
-    
    def __str__(self):
        return 'Resume' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
    def scan(self, cur_cpu, switches):
        if cur_cpu[0] != Event.NO_CPU and cur_cpu[0] != self.get_cpu():
            self.erroneous = True
            #print "Resuming when currently scheduled on a CPU, but on a different CPU from the current CPU!"
        super(ResumeEvent, self).scan(cur_cpu, switches)
-        
    def render(self, graph, layer, prev_events, selectable=False):
        if layer == self.layer:
            prev_events[self] = None
@@ -402,19 +402,19 @@ class ResumeEvent(Event):
            else:
                graph.draw_resume_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                               self.get_cpu(), self.is_selected())
-                
-        
 class CompleteEvent(Event):
    def __init__(self, time, cpu):
        super(CompleteEvent, self).__init__(time, cpu)
        self.layer = Canvas.TOP_LAYER
-    
    def __str__(self):
        return 'Complete' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
    def scan(self, cur_cpu, switches):
        super(CompleteEvent, self).scan(cur_cpu, switches)
-    
    def render(self, graph, layer, prev_events, selectable=False):
        if layer == Canvas.TOP_LAYER:
            prev_events[self] = None
@@ -430,7 +430,7 @@ class SwitchToEvent(Event):
        super(SwitchToEvent, self).__init__(time, cpu)
        self.layer = Canvas.BOTTOM_LAYER
        self.corresp_end_event = None
-        
    def __str__(self):
        if self.corresp_end_event is None:
            return 'Switch To (w/o Switch Away)' + self._common_str() + ', TIME=' \
@@ -438,19 +438,19 @@ class SwitchToEvent(Event):
        return 'Scheduled' + self._common_str() + ', START=' \
               + util.format_float(self.get_time(), Event.NUM_DEC_PLACES) \
               + ', END=' + util.format_float(self.corresp_end_event.get_time(), Event.NUM_DEC_PLACES)
-        
    def scan(self, cur_cpu, switches):
        old_cur_cpu = cur_cpu[0]
        cur_cpu[0] = self.get_cpu()
        switches[SwitchToEvent] = self
        self.corresp_end_event = None
-        
        if old_cur_cpu != Event.NO_CPU:
            self.erroneous = True
            #print "currently scheduled somewhere, can't switch to a CPU"
-                            
        super(SwitchToEvent, self).scan(cur_cpu, switches)
-    
    def render(self, graph, layer, prev_events, selectable=False):
        if layer == self.layer:
            end_time = None
@@ -460,7 +460,7 @@ class SwitchToEvent(Event):
                clip = AlignMode.RIGHT
            else:
                end_time = self.corresp_end_event.get_time()
-            
            prev_events[self] = None
            cpu = self.get_cpu()
            task_no = self.get_job().get_task().get_task_no()
@@ -471,30 +471,30 @@ class SwitchToEvent(Event):
                graph.draw_bar_at_time(self.get_time(), end_time,
                                   task_no, cpu, self.get_job().get_job_no(),
                                   clip, self.is_selected())
-                                           
 class SwitchAwayEvent(Event):
    def __init__(self, time, cpu):
        super(SwitchAwayEvent, self).__init__(time, cpu)
        self.layer = Canvas.BOTTOM_LAYER
        self.corresp_start_event = None
-    
    def __str__(self):
        if self.corresp_start_event is None:
            return 'Switch Away (w/o Switch To)' + self._common_str() + 'TIME=' \
                   + str(self.get_time())
        return str(self.corresp_start_event)
-            
    def scan(self, cur_cpu, switches):
        old_cur_cpu = cur_cpu[0]
-        
        self.corresp_start_event = switches[SwitchToEvent]
-        
        cur_cpu[0] = Event.NO_CPU
        switches[SwitchToEvent] = None
-        
        if self.corresp_start_event is not None:
            self.corresp_start_event.corresp_end_event = self
-            
        if self.get_cpu() != old_cur_cpu:
            self.erroneous = True
            #print "switching away from a CPU different from the CPU we are currently on"
@@ -504,9 +504,9 @@ class SwitchAwayEvent(Event):
        elif self.get_time() < self.corresp_start_event.get_time():
            self.erroneous = True
            #print "switching away from a processor before we switched to it?!"
-        
        super(SwitchAwayEvent, self).scan(cur_cpu, switches)
-            
    def render(self, graph, layer, prev_events, selectable=False):
        if self.corresp_start_event is None:
            # We never found a corresponding start event. In that case, we can assume it lies
@@ -528,18 +528,18 @@ class SwitchAwayEvent(Event):
            if self.corresp_start_event in prev_events:
                return # already rendered the bar
            self.corresp_start_event.render(graph, layer, prev_events, selectable)
-        
 class ReleaseEvent(Event):
    def __init__(self, time, cpu):
        super(ReleaseEvent, self).__init__(time, cpu)
        self.layer = Canvas.TOP_LAYER
-    
    def __str__(self):
        return 'Release' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-        
    def scan(self, cur_cpu, switches):
        super(ReleaseEvent, self).scan(cur_cpu, switches)
-        
    def render(self, graph, layer, prev_events, selectable=False):
        prev_events[self] = None
        if layer == Canvas.TOP_LAYER:
@@ -549,19 +549,19 @@ class ReleaseEvent(Event):
            else:
                graph.draw_release_arrow_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                             self.get_job().get_job_no(), self.is_selected())
-            
-                                             
 class DeadlineEvent(Event):
    def __init__(self, time, cpu):
        super(DeadlineEvent, self).__init__(time, cpu)
        self.layer = Canvas.TOP_LAYER
-    
    def __str__(self):
        return 'Deadline' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
    def scan(self, cur_cpu, switches):
        super(DeadlineEvent, self).scan(cur_cpu, switches)
-        
    def render(self, graph, layer, prev_events, selectable=False):
        prev_events[self] = None
        if layer == Canvas.TOP_LAYER:
@@ -571,14 +571,14 @@ class DeadlineEvent(Event):
            else:
                graph.draw_deadline_arrow_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                              self.get_job().get_job_no(), self.is_selected())
-            
 class InversionStartEvent(ErrorEvent):
    def __init__(self, time):
        super(InversionStartEvent, self).__init__(time, Event.NO_CPU)
        self.layer = Canvas.BOTTOM_LAYER
        self.corresp_end_event = None
-    
    def __str__(self):
        if self.corresp_end_event is None:
            return 'Inversion Start (w/o Inversion End)' + self._common_str() \
@@ -586,14 +586,14 @@ class InversionStartEvent(ErrorEvent):
        return 'Priority Inversion' + self._common_str() + ', START=' \
               + util.format_float(self.get_time(), Event.NUM_DEC_PLACES) \
               + ', END=' + util.format_float(self.corresp_end_event.get_time(), Event.NUM_DEC_PLACES)
-        
    def scan(self, cur_cpu, switches):
        switches[InversionStartEvent] = self
        self.corresp_end_event = None
-        
        # the corresp_end_event should already be set
        super(InversionStartEvent, self).scan(cur_cpu, switches)
-    
    def render(self, graph, layer, prev_events, selectable=False):
        if layer == self.layer:
            end_time = None
@@ -603,7 +603,7 @@ class InversionStartEvent(ErrorEvent):
                clip = AlignMode.RIGHT
            else:
                end_time = self.corresp_end_event.get_time()
-            
            if layer == self.layer:
                prev_events[self] = None
                cpu = self.get_cpu()
@@ -615,36 +615,36 @@ class InversionStartEvent(ErrorEvent):
                    graph.draw_mini_bar_at_time(self.get_time(), end_time,
                                     task_no, cpu, self.get_job().get_job_no(),
                                     clip, self.is_selected())
-            
 class InversionEndEvent(ErrorEvent):
    def __init__(self, time):
        super(InversionEndEvent, self).__init__(time, Event.NO_CPU)
        self.layer = Canvas.BOTTOM_LAYER
        self.corresp_start_event = None
-    
    def __str__(self):
        if self.corresp_start_event is None:
            return 'Inversion End (w/o Inversion Start)' + self._common_str() \
                  + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-        
        return str(self.corresp_start_event)
-                      
    def scan(self, cur_cpu, switches):
        self.corresp_start_event = switches[InversionStartEvent]
-        
        cur_cpu[0] = Event.NO_CPU
        switches[InversionStartEvent] = None
-        
        if self.corresp_start_event is not None:
            self.corresp_start_event.corresp_end_event = self
-            
        if self.corresp_start_event is None:
            self.erroneous = True
            print "inversion end was not matched by a corresponding inversion start"
-        
        super(InversionEndEvent, self).scan(cur_cpu, switches)
-        
    def render(self, graph, layer, prev_events, selectable=False):
        if self.corresp_start_event is None:
            # We never found a corresponding start event. In that case, we can assume it lies
@@ -666,27 +666,27 @@ class InversionEndEvent(ErrorEvent):
            if self.corresp_start_event in prev_events:
                return # already rendered the bar
            self.corresp_start_event.render(graph, layer, prev_events, selectable)
-        
 class InversionDummy(DummyEvent):
    def __init__(self, time, cpu):
        super(InversionDummy, self).__init__(time, Event.NO_CPU)
        self.layer = Canvas.BOTTOM_LAYER
-        
    def render(self, graph, layer, prev_events, selectable=False):
        if self.corresp_start_event is None:
            if self.corresp_end_event in prev_events:
                return # we have already been rendered
            self.corresp_end_event.render(graph, layer, prev_events, selectable)
-        else:    
+        else:
            if self.corresp_start_event in prev_events:
                return # we have already been rendered
            self.corresp_start_event.render(graph, layer, prev_events, selectable)
-        
 class IsRunningDummy(DummyEvent):
    def __init__(self, time, cpu):
        super(IsRunningDummy, self).__init__(time, Event.NO_CPU)
        self.layer = Canvas.BOTTOM_LAYER
-        
    def render(self, graph, layer, prev_events, selectable=False):
        if self.corresp_start_event is None:
            if self.corresp_end_event in prev_events:
diff --git a/unit_trace/viz/viewer.py b/unit_trace/viz/viewer.py
index 909da76..efc79a1 100644
--- a/unit_trace/viz/viewer.py
+++ b/unit_trace/viz/viewer.py
@@ -13,10 +13,10 @@ import copy
 class GraphContextMenu(gtk.Menu):
    MAX_STR_LEN = 80
-    
    def __init__(self, selected):
        super(GraphContextMenu, self).__init__()
-        
        for event in selected:
            string = str(event)
            if len(string) > GraphContextMenu.MAX_STR_LEN - 3:
@@ -24,100 +24,100 @@ class GraphContextMenu(gtk.Menu):
            item = gtk.MenuItem(string)
            self.append(item)
            item.show()
-            
 class GraphArea(gtk.DrawingArea):
    HORIZ_PAGE_SCROLL_FACTOR = 10.8
    HORIZ_STEP_SCROLL_FACTOR = 0.8
    VERT_PAGE_SCROLL_FACTOR = 3.0
    VERT_STEP_SCROLL_FACTOR = 0.5
-    
    REFRESH_INFLATION_FACTOR = 20.0
-    
    def __init__(self, renderer):
        super(GraphArea, self).__init__()
-        
        self.renderer = renderer
-        
        self.cur_x = 0
        self.cur_y = 0
        self.width = 0
        self.height = 0
-        
        self.set_set_scroll_adjustments_signal('set-scroll-adjustments')
-        
        self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK |
                        gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.EXPOSURE_MASK)
-        
        self.band_rect = None
        self.ctrl_clicked = False
        self.dirtied_regions = []
-        
        self.connect('expose-event', self.expose)
        self.connect('size-allocate', self.size_allocate)
        self.connect('set-scroll-adjustments', self.set_scroll_adjustments)
        self.connect('button-press-event', self.button_press)
        self.connect('button-release-event', self.button_release)
        self.connect('motion-notify-event', self.motion_notify)
-        
    def expose(self, widget, expose_event, data=None):
        ctx = widget.window.cairo_create()
        graph = self.renderer.get_graph()
        graph.update_view(self.cur_x, self.cur_y, self.width, self.height, ctx)
-        
        # We ourselves didn't update dirtied_regions, so this means that X or the
        # window manager must have caused the expose event. So just update the
        # expose_event's bounding area.
        if not self.dirtied_regions or expose_event.send_event:
            self.dirtied_regions = [(expose_event.area.x, expose_event.area.y,
                                     expose_event.area.width, expose_event.area.height)]
-                                  
        graph.render_surface(self.renderer.get_schedule(), self.dirtied_regions)
-        
        # render dragging band rectangle, if there is one
        if self.band_rect is not None:
            x, y, width, height = self.band_rect
            thickness = GraphFormat.BAND_THICKNESS
            color = GraphFormat.BAND_COLOR
-            
-            ctx.rectangle(x, y, width, height)            
+            ctx.rectangle(x, y, width, height)
            ctx.set_line_width(thickness)
            ctx.set_source_rgb(color[0], color[1], color[2])
            ctx.stroke()
-        
        self.dirtied_regions = []
-        
    def get_renderer(self):
        return self.renderer
-        
    def get_graph(self):
        return self.renderer.get_graph()
-            
    def set_scroll_adjustments(self, widget, horizontal, vertical, data=None):
        graph = self.renderer.get_graph()
        width = graph.get_width()
        height = graph.get_height()
-        
        self.horizontal = horizontal
        self.vertical = vertical
        self.config_scrollbars(self.cur_x, self.cur_y)
-        
-        if self.horizontal is not None:                         
+        if self.horizontal is not None:
            self.horizontal.connect('value-changed', self.horizontal_value_changed)
        if self.vertical is not None:
            self.vertical.connect('value-changed', self.vertical_value_changed)
-        
    def horizontal_value_changed(self, adjustment):
        self.cur_x = min(adjustment.value, self.renderer.get_graph().get_width())
        self.cur_x = max(adjustment.value, 0.0)
-        
        self._dirty(0, 0, self.width, self.height)
-    
    def vertical_value_changed(self, adjustment):
        self.cur_y = min(adjustment.value, self.renderer.get_graph().get_height())
        self.cur_y = max(adjustment.value, 0.0)
-        
        self._dirty(0, 0, self.width, self.height)
-            
    def size_allocate(self, widget, allocation):
        self.width = allocation.width
        self.height = allocation.height
@@ -127,21 +127,21 @@ class GraphArea(gtk.DrawingArea):
        graph = self.renderer.get_graph()
        width = graph.get_width()
        height = graph.get_height()
-        
        if self.horizontal is not None:
            self.horizontal.set_all(hvalue, 0.0, width, graph.get_attrs().maj_sep * GraphArea.HORIZ_STEP_SCROLL_FACTOR,
                                graph.get_attrs().maj_sep * GraphArea.HORIZ_PAGE_SCROLL_FACTOR, self.width)
        if self.vertical is not None:
            self.vertical.set_all(vvalue, 0.0, height, graph.get_attrs().y_item_size * GraphArea.VERT_STEP_SCROLL_FACTOR,
-                                graph.get_attrs().y_item_size * GraphArea.VERT_PAGE_SCROLL_FACTOR, self.height) 
+                                graph.get_attrs().y_item_size * GraphArea.VERT_PAGE_SCROLL_FACTOR, self.height)
-    
    def _find_max_layer(self, regions):
        max_layer = Canvas.BOTTOM_LAYER
        for event in regions:
            if event.get_layer() > max_layer:
                max_layer = event.get_layer()
        return max_layer
-    
    def _update_event_changes(self, list1, list2):
        # if an event changed selected status, update the bounding area
        for event in list1:
@@ -152,12 +152,12 @@ class GraphArea(gtk.DrawingArea):
            if event not in list1:
                x, y, width, height = list2[event].get_dimensions()
                self._dirty_inflate(x - self.cur_x, y - self.cur_y, width, height, GraphFormat.BORDER_THICKNESS)
-                        
    def motion_notify(self, widget, motion_event, data=None):
        msg = None
-        
        graph = self.renderer.get_graph()
-        
        graph.render_surface(self.renderer.get_schedule(), [(motion_event.x, motion_event.y,
                             0, 0)], True)
        just_selected = graph.get_selected_regions(motion_event.x, motion_event.y, 0, 0)
@@ -166,62 +166,62 @@ class GraphArea(gtk.DrawingArea):
            the_event = None
        else:
            max_layer = self._find_max_layer(just_selected)
-        
            for event in just_selected:
                if event.get_layer() == max_layer:
                    the_event = event
                    break
-            
            msg = str(the_event)
-        
        self.emit('update-event-description', the_event, msg)
-        
        if self.band_rect is not None:
            selected = {}
            was_selected = self.renderer.get_schedule().get_selected()
            if self.ctrl_clicked:
                selected = copy.copy(was_selected)
-                
            # dragging a rectangle
            x = self.band_rect[0]
            y = self.band_rect[1]
            width = motion_event.x - self.band_rect[0]
            height = motion_event.y - self.band_rect[1]
-            
            x_p, y_p, width_p, height_p = self._positivify(x, y, width, height)
            graph.render_surface(self.renderer.get_schedule(), [(x_p, y_p, width_p, height_p)], True)
            selected.update(graph.get_selected_regions(x_p, y_p, width_p, height_p))
            self.renderer.get_schedule().set_selected(selected)
-    
            old_x, old_y, old_width, old_height = self.band_rect
            self.band_rect = (x, y, width, height)
-            
            self._dirty_rect_border(old_x, old_y, old_width, old_height, GraphFormat.BAND_THICKNESS)
            self._dirty_rect_border(x, y, width, height, GraphFormat.BAND_THICKNESS)
-        
            self._update_event_changes(was_selected, selected)
-            
    def button_press(self, widget, button_event, data=None):
        graph = self.renderer.get_graph()
-        
        self.ctrl_clicked = button_event.state & gtk.gdk.CONTROL_MASK
-        
        if button_event.button == 1:
            self.left_button_start_coor = (button_event.x, button_event.y)
            graph.render_surface(self.renderer.get_schedule(), \
                                 [(button_event.x, button_event.y, 0, 0)], True)
-            
            just_selected = graph.get_selected_regions(button_event.x, button_event.y, 0, 0)
-            
            max_layer = self._find_max_layer(just_selected)
-            
            new_now_selected = None
            was_selected = self.renderer.get_schedule().get_selected()
            if self.ctrl_clicked:
                new_now_selected = copy.copy(was_selected)
            else:
                new_now_selected = {}
-                
            # only select those events which were in the top layer (it's
            # not intuitive to click something and then have something
            # below it get selected). Also, clicking something that
@@ -237,43 +237,43 @@ class GraphArea(gtk.DrawingArea):
                    elif event in new_now_selected:
                        del new_now_selected[event]
                    break # only pick one event when just clicking
-            
            self.renderer.get_schedule().set_selected(new_now_selected)
            #self.last_selected = new_now_selected
-            
            self._update_event_changes(new_now_selected, was_selected)
-            
            if self.band_rect is None:
                self.band_rect = (button_event.x, button_event.y, 0, 0)
-                    
        elif button_event.button == 3:
            self._release_band()
            self.emit('request-context-menu', button_event, self.renderer.get_schedule().get_selected())
-                                    
    def button_release(self, widget, button_event, data=None):
        self.ctrl_clicked = False
        #self.last_selected = copy.copy(self.renderer.get_schedule().get_selected())
-        
        if button_event.button == 1:
            self._release_band()
-    
    def _release_band(self):
        if self.band_rect is not None:
            x, y, width, height = self.band_rect
            self._dirty_rect_border(x, y, width, height, GraphFormat.BAND_THICKNESS)
            self.band_rect = None
-                            
    def _dirty(self, x, y, width, height):
        x = max(int(math.floor(x)), 0)
        y = max(int(math.floor(y)), 0)
        width = min(int(math.ceil(width)), self.width)
        height = min(int(math.ceil(height)), self.height)
-        
        self.dirtied_regions.append((x, y, width, height))
-        
        rect = gtk.gdk.Rectangle(x, y, width, height)
        self.window.invalidate_rect(rect, True)
-    
    def _dirty_inflate(self, x, y, width, height, thickness):
        t = thickness * GraphArea.REFRESH_INFLATION_FACTOR
        x -= t / 2.0
@@ -281,17 +281,17 @@ class GraphArea(gtk.DrawingArea):
        width += t
        height += t
        self._dirty(x, y, width, height)
-        
    def _dirty_rect_border(self, x, y, width, height, thickness):
        # support rectangles with negative width and height (i.e. -width = width, but going leftwards
        # instead of rightwards)
        x, y, width, height = self._positivify(x, y, width, height)
-        
        self._dirty_inflate(x, y, width, 0, thickness)
        self._dirty_inflate(x, y, 0, height, thickness)
        self._dirty_inflate(x, y + height, width, 0, thickness)
        self._dirty_inflate(x + width, y, 0, height, thickness)
-    
    def _positivify(self, x, y, width, height):
        if width < 0:
            x += width
@@ -299,28 +299,28 @@ class GraphArea(gtk.DrawingArea):
        if height < 0:
            y += height
            height = -height
-        
        return x, y, width, height
-        
-class GraphWindow(gtk.ScrolledWindow):    
+class GraphWindow(gtk.ScrolledWindow):
    def __init__(self, renderer):
        super(GraphWindow, self).__init__(None, None)
-        
        self.add_events(gtk.gdk.KEY_PRESS_MASK)
-        
        self.ctr = 0
        self.connect('key-press-event', self.key_press)
-                                
        self.garea = GraphArea(renderer)
        self.add(self.garea)
        self.garea.show()
-    
    def key_press(self, widget, key_event):
        hadj = self.get_hadjustment()
        vadj = self.get_vadjustment()
        if hadj is None or vadj is None:
            return
-            
        hupper = hadj.get_upper()
        hlower = hadj.get_lower()
        hpincr = hadj.get_page_increment()
@@ -333,9 +333,9 @@ class GraphWindow(gtk.ScrolledWindow):
        vpincr = vadj.get_page_increment()
        vsincr = vadj.get_step_increment()
        vpsize = vadj.get_page_size()
-        
        ctrl_clicked = key_event.state & gtk.gdk.CONTROL_MASK
-        
        adj_tuple = {'up' :     (vadj, -vsincr, 0, vval, max),
                     'ctrl-up' :    (vadj, -vpincr, 0, vval, max),
                     'down' :   (vadj, vsincr, vupper - vpsize, vval, min),
@@ -344,78 +344,78 @@ class GraphWindow(gtk.ScrolledWindow):
                     'ctrl-left' :  (hadj, -hpincr, 0, hval, max),
                     'right' :  (hadj, hsincr, hupper - hpsize, hval, min),
                     'ctrl-right' : (hadj, hpincr, hupper - hpsize, hval, min)}
-                     
        keystr = None
        keymap = {gtk.keysyms.Up : 'up', gtk.keysyms.Down : 'down',
                  gtk.keysyms.Left : 'left', gtk.keysyms.Right : 'right'}
-        if key_event.keyval in keymap:        
+        if key_event.keyval in keymap:
            keystr = keymap[key_event.keyval]
-                  
        if ctrl_clicked:
            keystr = 'ctrl-' + keystr
-            
        if keystr is not None:
            adj, inc, lim, val, extr = adj_tuple[keystr]
            adj.set_value(extr(val + inc, lim))
-            
        return True
-        
    def get_graph_area(self):
        return self.garea
-                        
 class MainWindow(gtk.Window):
    WINDOW_WIDTH_REQ = 500
    WINDOW_HEIGHT_REQ = 300
-    
    def __init__(self):
        super(MainWindow, self).__init__(gtk.WINDOW_TOPLEVEL)
-        
        self.connect('delete_event', self.delete_event)
        self.connect('destroy', self.die)
-        
        self.file_menu = gtk.Menu()
        self.quit_item = gtk.MenuItem('_Quit', True)
        self.quit_item.connect('activate', self.quit_item_activate)
        self.quit_item.show()
        self.file_menu.append(self.quit_item)
-        
        self.file_item = gtk.MenuItem('_File', True)
        self.file_item.set_submenu(self.file_menu)
        self.file_item.show()
-        
        self.menu_bar = gtk.MenuBar()
        self.menu_bar.append(self.file_item)
-        
        self.menu_bar.show()
-        
        self.vbox = gtk.VBox(False, 0)
-        
        self.notebook = gtk.Notebook()
-        
        self.notebook.last_page = -1
        self.notebook.connect('switch-page', self.switch_page)
-            
        self.notebook.show()
-        
        self.desc_label = gtk.Label('')
        self.desc_label.set_justify(gtk.JUSTIFY_LEFT)
        self.desc_label.show()
-        
        self.vbox.pack_start(self.menu_bar, False, False, 0)
        self.vbox.pack_start(self.notebook, True, True, 0)
        self.vbox.pack_start(self.desc_label, False, False, 0)
        self.vbox.show()
-        
        self.add(self.vbox)
-        
        self.set_size_request(MainWindow.WINDOW_WIDTH_REQ, MainWindow.WINDOW_HEIGHT_REQ)
-        
        self.show()
    def connect_widgets(self, garea):
-        garea.connect('update-event-description', self.update_event_description)      
+        garea.connect('update-event-description', self.update_event_description)
        garea.connect('request-context-menu', self.request_context_menu)
-    
    def set_renderers(self, renderers):
        for i in range(0, self.notebook.get_n_pages()):
            self.notebook.remove_page(0)
@@ -424,7 +424,7 @@ class MainWindow(gtk.Window):
            self.connect_widgets(gwindow.get_graph_area())
            gwindow.show()
            self.notebook.append_page(gwindow, gtk.Label(title))
-        
    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()
@@ -432,27 +432,27 @@ class MainWindow(gtk.Window):
            new_ofs = self.notebook.get_nth_page(page_num).get_graph_area().get_graph().get_origin()[0]
            new_value = old_value - old_ofs + new_ofs
            self.notebook.get_nth_page(page_num).get_hadjustment().set_value(new_value)
-        
        self.notebook.last_page = page_num
-        
    def update_event_description(self, widget, event, msg):
        self.desc_label.set_text(msg)
-    
    def request_context_menu(self, widget, gdk_event, selected):
        button = 0
        if hasattr(gdk_event, 'button'):
           button = gdk_event.button
        time = gdk_event.time
-        
        menu = GraphContextMenu(selected)
        menu.popup(None, None, None, button, time)
-        
    def quit_item_activate(self, widget):
        self.destroy()
-            
    def delete_event(self, widget, event, data=None):
        return False
-        
    def die(self, widget, data=None):
        gtk.main_quit()
-    
diff --git a/unit_trace/viz/visualizer.py b/unit_trace/viz/visualizer.py
index d739736..63594bd 100755
--- a/unit_trace/viz/visualizer.py
+++ b/unit_trace/viz/visualizer.py
@@ -13,13 +13,13 @@ TIME_PER_MAJ = 10000000
 def visualizer(stream):
    sched = convert.convert_trace_to_schedule(stream)
    sched.scan(TIME_PER_MAJ)
-    
    task_renderer = renderer.Renderer(sched)
    task_renderer.prepare_task_graph(attrs=format.GraphFormat(time_per_maj=TIME_PER_MAJ))
    cpu_renderer = renderer.Renderer(sched)
    cpu_renderer.prepare_cpu_graph(attrs=format.GraphFormat(time_per_maj=TIME_PER_MAJ))
-    
    window = viewer.MainWindow()
    window.set_renderers({'Tasks' : task_renderer, 'CPUs' : cpu_renderer})
-    
    gtk.main()
author	Mac Mollison <mollison@cs.unc.edu>	2010-03-20 17:40:00 -0400
committer	Mac Mollison <mollison@cs.unc.edu>	2010-03-20 17:40:00 -0400
commit	90d1825ad3ad20430734c1c75b899d14c4e6b700 (patch)
tree	834a898b506f37a35c73d3845061ec8f7284394e
parent	7fdb4dbbbca577efbeec47cd1364eb319346a0cc (diff)