1 files changed, 222 insertions, 222 deletions

diff --git a/unit_trace/viz/graph.py b/unit_trace/viz/graph.py
index 6982e7c..a10d9bd 100644
--- a/unit_trace/viz/graph.py
+++ b/unit_trace/viz/graph.py
@@ -13,7 +13,7 @@ class Graph(object):
                      Pattern([(0.75, 0.75, 0.75)])]
     DEF_ITEM_CLIST = [(0.3, 0.0, 0.0), (0.0, 0.3, 0.0), (0.0, 0.0, 0.3), (0.3, 0.3, 0.0), (0.0, 0.3, 0.3),
                       (0.3, 0.0, 0.3)]
-    
+
     def __init__(self, CanvasType, surface, start_time, end_time, y_item_list, attrs=GraphFormat(),
                  item_clist=DEF_ITEM_CLIST, bar_plist=DEF_BAR_PLIST):
         # deal with possibly blank schedules
@@ -21,16 +21,16 @@ class Graph(object):
             start_time = 0
         if end_time is None:
             end_time = 0
-         
+
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
+
         self.attrs = attrs
         self.start_time = start_time
         self.end_time = end_time
         self.y_item_list = y_item_list
         self.num_maj = int(math.ceil((self.end_time - self.start_time) * 1.0 / self.attrs.time_per_maj)) + 1
-    
+
         width = self.num_maj * self.attrs.maj_sep + GraphFormat.X_AXIS_MEASURE_OFS + GraphFormat.WIDTH_PAD
         height = (len(self.y_item_list) + 1) * self.attrs.y_item_size + GraphFormat.HEIGHT_PAD
 
@@ -40,7 +40,7 @@ class Graph(object):
         extra_width = 0.0
         dummy_surface = surface.__class__()
         dummy_surface.renew(10, 10)
-        
+
         dummy_surface.ctx.select_font_face(self.attrs.item_fopts.name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
         dummy_surface.ctx.set_font_size(self.attrs.item_fopts.size)
         for item in self.y_item_list:
@@ -49,49 +49,49 @@ class Graph(object):
             cur_width = te[2]
             if cur_width > extra_width:
                 extra_width = cur_width
-            
+
         width += extra_width
-        
+
         self.origin = (extra_width + GraphFormat.WIDTH_PAD / 2.0, height - GraphFormat.HEIGHT_PAD / 2.0)
-        
+
         self.width = width
         self.height = height
-        
+
         #if surface.ctx is None:
         #    surface.renew(width, height)
-        
+
         self.canvas = CanvasType(width, height, item_clist, bar_plist, surface)
-    
+
     def get_selected_regions(self, real_x, real_y, width, height):
         return self.canvas.get_selected_regions(real_x, real_y, width, height)
-                
+
     def get_width(self):
         return self.width
-        
+
     def get_height(self):
         return self.height
-    
+
     def get_origin(self):
         return self.origin
-        
+
     def get_attrs(self):
         return self.attrs
-    
+
     def add_sel_region(self, region):
         self.canvas.add_sel_region(region)
-    
+
     def get_sel_region(self, event):
         return self.canvas.get_sel_region(event)
-    
+
     def has_sel_region(self, event):
         return self.canvas.has_sel_region(event)
-            
+
     def update_view(self, x, y, width, height, scale, ctx):
         """Proxy into the surface's pan."""
         self.canvas.surface.pan(x, y, width, height)
         self.canvas.set_scale(scale)
         self.canvas.surface.change_ctx(ctx)
-    
+
     def _recomp_min_max(self, start_time, end_time, start_item, end_item):
         if self.min_time is None or start_time < self.min_time:
             self.min_time = start_time
@@ -101,93 +101,93 @@ class Graph(object):
             self.min_item = start_item
         if self.max_item is None or end_item > self.max_item:
             self.max_item = end_item
-        
-    def _get_time_xpos(self, time):
+
+    def get_time_xpos(self, time):
         """get x so that x is at instant ``time'' on the graph"""
         return self.origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + 1.0 * (time - self.start_time) / self.attrs.time_per_maj * self.attrs.maj_sep
-    
-    def _get_item_ypos(self, item_no):
+
+    def get_item_ypos(self, item_no):
         """get y so that y is where the top of a bar would be in item #n's area"""
-        return self.origin[1] - self._get_y_axis_height() + self.attrs.y_item_size * (item_no + 0.5 - GraphFormat.BAR_SIZE_FACTOR / 2.0)     
-    
+        return self.origin[1] - self._get_y_axis_height() + self.attrs.y_item_size * (item_no + 0.5 - GraphFormat.BAR_SIZE_FACTOR / 2.0)
+
     def _get_bar_width(self, start_time, end_time):
         return 1.0 * (end_time - start_time) / self.attrs.time_per_maj * self.attrs.maj_sep
-    
+
     def _get_bar_height(self):
         return self.attrs.y_item_size * GraphFormat.BAR_SIZE_FACTOR
-    
+
     def _get_mini_bar_height(self):
         return self.attrs.y_item_size * GraphFormat.MINI_BAR_SIZE_FACTOR
-        
+
     def _get_mini_bar_ofs(self):
         return self.attrs.y_item_size * (GraphFormat.MINI_BAR_SIZE_FACTOR + GraphFormat.BAR_MINI_BAR_GAP_FACTOR)
-        
+
     def _get_y_axis_height(self):
         return (len(self.y_item_list) + 1) * self.attrs.y_item_size
-    
+
     def _get_bottom_tick(self, time):
         return int(math.floor((time - self.start_time) / self.attrs.time_per_maj))
-    
+
     def _get_top_tick(self, time):
         return int(math.ceil((time - self.start_time) / self.attrs.time_per_maj))
-        
+
     def get_surface(self):
         """Gets the underlying surface."""
         return self.canvas.get_surface()
-    
+
     def xcoor_to_time(self, x):
         #x = self.origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + (time - self.start) / self.attrs.time_per_maj * self.attrs.maj_sep
         return (x - self.origin[0] - GraphFormat.X_AXIS_MEASURE_OFS) / self.attrs.maj_sep \
                 * self.attrs.time_per_maj + self.start_time
-    
+
     def ycoor_to_item_no(self, y):
-        return int((y - self.origin[1] + self._get_y_axis_height()) // self.attrs.y_item_size) 
-    
+        return int((y - self.origin[1] + self._get_y_axis_height()) // self.attrs.y_item_size)
+
     def get_offset_params(self, real_x, real_y, width, height):
         x_start, y_start = self.canvas.surface.get_virt_coor_unscaled(real_x, real_y)
         x_end, y_end = self.canvas.surface.get_virt_coor_unscaled(real_x + width, real_y + height)
-        
+
         start_time = self.xcoor_to_time(x_start)
         end_time = self.xcoor_to_time(x_end)
-        
+
         start_item = self.ycoor_to_item_no(y_start)
         end_item = 1 + self.ycoor_to_item_no(y_end)
-        
+
         return (start_time, end_time, start_item, end_item)
-    
+
     def draw_skeleton(self, start_time, end_time, start_item, end_item):
         self.draw_grid_at_time(start_time, end_time, start_item, end_item)
         self.draw_x_axis_with_labels_at_time(start_time, end_time)
         self.draw_y_axis_with_labels()
-            
+
     def render_surface(self, sched, regions, selectable=False):
         raise NotImplementedError
-    
+
     def render_all(self, schedule):
         raise NotImplementedError
-    
+
     def get_events_to_render(self, sched, regions, selectable=False):
         raise NotImplementedError
-        
+
     def render_surface(self, sched, regions, selectable=False):
         if not selectable:
             self.canvas.whiteout()
         else:
             self.canvas.clear_selectable_regions()
         self.render_events(self.get_events_to_render(sched, regions, selectable), selectable)
-        
+
     def render_events(self, events, selectable=False):
         for layer in Canvas.LAYERS:
             prev_events = {}
             if layer in events:
                 for event in events[layer]:
                     event.render(self, layer, prev_events, selectable)
-                                        
+
     def draw_axes(self, x_axis_label, y_axis_label):
         """Draws and labels the axes according to the parameters that we were initialized
-        with."""    
+        with."""
         self.draw_grid_at_time(self.start_time, self.end_time, 0, len(self.attrs.y_item_list) - 1)
-        
+
         self.canvas.draw_x_axis(self.origin[0], self.origin[1], self.num_maj, self.attrs.maj_sep, self.attrs.min_per_maj)
         self.canvas.draw_y_axis(self.origin[0], self.origin[1], self._get_y_axis_height())
         self.canvas.draw_x_axis_labels(self.origin[0], self.origin[1], 0, self.num_maj - 1,\
@@ -195,425 +195,425 @@ class Graph(object):
                                 self.attrs.time_per_maj, self.attrs.show_min, self.attrs.majfopts, self.attrs.minfopts)
         self.canvas.draw_y_axis_labels(self.origin[0], self.origin[1], self._get_y_axis_height(), self.y_item_list, \
                                        self.attrs.y_item_size, self.attrs.item_fopts)
-    
+
     def draw_grid_at_time(self, start_time, end_time, start_item, end_item):
         """Draws the grid, but only in a certain time and item range."""
         start_tick = max(0, self._get_bottom_tick(start_time))
         end_tick = min(self.num_maj - 1, self._get_top_tick(end_time))
-        
+
         start_item = max(0, start_item)
         end_item = min(len(self.y_item_list), end_item)
-        
+
         self.canvas.draw_grid(self.origin[0], self.origin[1], self._get_y_axis_height(),
                               start_tick, end_tick, start_item, end_item, self.attrs.maj_sep, self.attrs.y_item_size, \
                               self.attrs.min_per_maj, True)
-    
+
     def draw_x_axis_with_labels_at_time(self, start_time, end_time):
         start_tick = max(0, self._get_bottom_tick(start_time))
         end_tick = min(self.num_maj - 1, self._get_top_tick(end_time))
-                                      
+
         self.canvas.draw_x_axis(self.origin[0], self.origin[1], start_tick, end_tick, \
                                 self.attrs.maj_sep, self.attrs.min_per_maj)
         self.canvas.draw_x_axis_labels(self.origin[0], self.origin[1], start_tick, \
                                 end_tick, self.attrs.maj_sep, self.attrs.min_per_maj,
                                 self.start_time + start_tick * self.attrs.time_per_maj,
                                 self.attrs.time_per_maj, False)
-                                
+
     def draw_y_axis_with_labels(self):
         self.canvas.draw_y_axis(self.origin[0], self.origin[1], self._get_y_axis_height())
         self.canvas.draw_y_axis_labels(self.origin[0], self.origin[1], self._get_y_axis_height(), \
                                        self.y_item_list, self.attrs.y_item_size)
-            
+
     def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         """Draws a suspension symbol for a dcertain task at an instant in time."""
         raise NotImplementedError
-    
+
     def add_sel_suspend_triangle_at_time(self, time, task_no, cpu_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-    
+
     def draw_resume_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         """Draws a resumption symbol for a certain task at an instant in time."""
         raise NotImplementedError
-    
+
     def add_sel_resume_triangle_at_time(self, time, task_no, cpu_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-            
+
     def draw_completion_marker_at_time(self, time, task_no, cpu_no, selected=False):
         """Draws a completion marker for a certain task at an instant in time."""
         raise NotImplementedError
-    
+
     def add_sel_completion_marker_at_time(self, time, task_no, cpu_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-            
+
     def draw_release_arrow_at_time(self, time, task_no, job_no, selected=False):
         """Draws a release arrow at a certain time for some task and job"""
         raise NotImplementedError
-    
+
     def add_sel_release_arrow_at_time(self, time, task_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-            
+
     def draw_deadline_arrow_at_time(self, time, task_no, job_no, selected=False):
         """Draws a deadline arrow at a certain time for some task and job"""
         raise NotImplementedError
-    
+
     def add_sel_deadline_arrow_at_time(self, time, task_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-        
+
     def draw_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None):
         """Draws a bar over a certain time period for some task, optionally labelling it."""
         raise NotImplementedError
-        
+
     def add_sel_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-    
+
     def draw_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, clip_side=None, job_no=None):
         """Draws a mini bar over a certain time period for some task, optionally labelling it."""
         raise NotImplementedError
-        
+
     def add_sel_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
         """Same as above, except instead of drawing adds a selectable region at
         a certain time."""
         raise NotImplementedError
-            
+
 class TaskGraph(Graph):
     def get_events_to_render(self, sched, regions, selectable=False):
         slots = {}
-        
-        self.min_time, self.max_time, self.min_item, self.max_item = None, None, None, None  
+
+        self.min_time, self.max_time, self.min_item, self.max_item = None, None, None, None
         for region in regions:
             x, y, width, height = region
             start_time, end_time, start_item, end_item = self.get_offset_params(x, y, width, height)
             self._recomp_min_max(start_time, end_time, start_item, end_item)
-            
+
             sched.get_time_slot_array().get_slots(slots,
                         start_time, end_time, start_item, end_item,
                         schedule.TimeSlotArray.TASK_LIST)
 
-        
+
         if not selectable:
             self.draw_skeleton(self.min_time, self.max_time,
                                self.min_item, self.max_item)
-        
+
         events_to_render = {}
         for layer in Canvas.LAYERS:
             events_to_render[layer] = {}
-        
+
         for event in sched.get_time_slot_array().get_events(slots,
                 schedule.TimeSlotArray.TASK_LIST,
                 schedule.EVENT_LIST):
-            events_to_render[event.get_layer()][event] = None    
-        
+            events_to_render[event.get_layer()][event] = None
+
         return events_to_render
-        
+
     def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
         self.canvas.draw_suspend_triangle(x, y, height, selected)
-    
+
     def add_sel_suspend_triangle_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.add_sel_suspend_triangle(x, y, height, event)
-        
+
     def draw_resume_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.draw_resume_triangle(x, y, height, selected)
-    
+
     def add_sel_resume_triangle_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.add_sel_resume_triangle(x, y, height, event)
-        
+
     def draw_completion_marker_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() - height
+
         self.canvas.draw_completion_marker(x, y, height, selected)
-    
+
     def add_sel_completion_marker_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() - height
+
         self.canvas.add_sel_completion_marker(x, y, height, event)
-            
+
     def draw_release_arrow_at_time(self, time, task_no, job_no=None, selected=False):
         height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() - height
+
         self.canvas.draw_release_arrow_big(x, y, height, selected)
-    
+
     def add_sel_release_arrow_at_time(self, time, task_no, event):
         height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no) + self._get_bar_height() - height
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no) + self._get_bar_height() - height
+
         self.canvas.add_sel_release_arrow_big(x, y, height, event)
-        
+
     def draw_deadline_arrow_at_time(self, time, task_no, job_no=None, selected=False):
         height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no)
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no)
+
         self.canvas.draw_deadline_arrow_big(x, y, height, selected)
-    
+
     def add_sel_deadline_arrow_at_time(self, time, task_no, event):
         height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(task_no)
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(task_no)
+
         self.canvas.add_sel_deadline_arrow_big(x, y, height, event)
-        
+
     def draw_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(task_no)
+
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(task_no)
         width = self._get_bar_width(start_time, end_time)
         height = self._get_bar_height()
-        
+
         self.canvas.draw_bar(x, y, width, height, cpu_no, clip_side, selected)
-        
+
         # if a job number is specified, we want to draw a superscript and subscript for the task and job number, respectively
         if job_no is not None:
             x += GraphFormat.BAR_LABEL_OFS
             y += self.attrs.y_item_size * GraphFormat.BAR_SIZE_FACTOR / 2.0
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                 GraphFormat.DEF_FOPTS_BAR, GraphFormat.DEF_FOPTS_BAR_SSCRIPT, AlignMode.LEFT, AlignMode.CENTER)
-    
+
     def add_sel_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(task_no)
+
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(task_no)
         width = self._get_bar_width(start_time, end_time)
         height = self._get_bar_height()
-        
+
         self.canvas.add_sel_bar(x, y, width, height, event)
-    
+
     def draw_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(task_no) - self._get_mini_bar_ofs()
+
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(task_no) - self._get_mini_bar_ofs()
         width = self._get_bar_width(start_time, end_time)
         height = self._get_mini_bar_height()
-        
+
         self.canvas.draw_mini_bar(x, y, width, height, Canvas.NULL_PATTERN, clip_side, selected)
-        
+
         if job_no is not None:
             x += GraphFormat.MINI_BAR_LABEL_OFS
             y += self.attrs.y_item_size * GraphFormat.MINI_BAR_SIZE_FACTOR / 2.0
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                 GraphFormat.DEF_FOPTS_MINI_BAR, GraphFormat.DEF_FOPTS_MINI_BAR_SSCRIPT, AlignMode.LEFT, AlignMode.CENTER)
-                
+
     def add_sel_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(task_no) - self._get_mini_bar_ofs()
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(task_no) - self._get_mini_bar_ofs()
         width = self._get_bar_width(start_time, end_time)
         height = self._get_mini_bar_height()
-        
+
         self.canvas.add_sel_mini_bar(x, y, width, height, event)
-        
+
 class CpuGraph(Graph):
     def get_events_to_render(self, sched, regions, selectable=False):
         BOTTOM_EVENTS = [schedule.ReleaseEvent, schedule.DeadlineEvent, schedule.InversionStartEvent,
                      schedule.InversionEndEvent, schedule.InversionDummy]
         TOP_EVENTS = [schedule.SuspendEvent, schedule.ResumeEvent, schedule.CompleteEvent,
                   schedule.SwitchAwayEvent, schedule.SwitchToEvent, schedule.IsRunningDummy]
-        
+
         if not regions:
             return {}
-            
+
         top_slots = {}
         bottom_slots = {}
-        
+
         self.min_time, self.max_time, self.min_item, self.max_item = None, None, None, None
         for region in regions:
             x, y, width, height = region
             start_time, end_time, start_item, end_item = self.get_offset_params(x, y, width, height)
             self._recomp_min_max(start_time, end_time, start_item, end_item)
-            
+
             sched.get_time_slot_array().get_slots(top_slots,
                         start_time, end_time, start_item, end_item,
                         schedule.TimeSlotArray.CPU_LIST)
-        
+
             if end_item >= len(self.y_item_list):
                 # we are far down enough that we should render the releases and deadlines and inversions,
                 # which appear near the x-axis
                 sched.get_time_slot_array().get_slots(bottom_slots,
                         start_time, end_time, 0, sched.get_num_cpus(),
                         schedule.TimeSlotArray.CPU_LIST)
-        
+
         if not selectable:
             self.draw_skeleton(self.min_time, self.max_time,
                                self.min_item, self.max_item)
-        
+
         events_to_render = {}
         for layer in Canvas.LAYERS:
             events_to_render[layer] = {}
-        
+
         for event in sched.get_time_slot_array().get_events(top_slots,
                 schedule.TimeSlotArray.CPU_LIST,
                 TOP_EVENTS):
-            events_to_render[event.get_layer()][event] = None  
+            events_to_render[event.get_layer()][event] = None
         for event in sched.get_time_slot_array().get_events(bottom_slots,
                 schedule.TimeSlotArray.CPU_LIST,
                 BOTTOM_EVENTS):
-            events_to_render[event.get_layer()][event] = None  
-        
+            events_to_render[event.get_layer()][event] = None
+
         return events_to_render
-                
+
     def render(self, schedule, start_time=None, end_time=None):
         if end_time < start_time:
             raise ValueError('start must be less than end')
-            
+
         if start_time is None:
             start_time = self.start
         if end_time is None:
             end_time = self.end
         start_slot = self.get_time_slot(start_time)
         end_slot = min(len(self.time_slots), self.get_time_slot(end_time) + 1)
-        
+
         for layer in Canvas.LAYERS:
             prev_events = {}
             for i in range(start_slot, end_slot):
                 for event in self.time_slots[i]:
                     event.render(graph, layer, prev_events)
-                    
+
     def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
         self.canvas.draw_suspend_triangle(x, y, height, selected)
-    
+
     def add_sel_suspend_triangle_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.add_sel_suspend_triangle(x, y, height, event)
-        
+
     def draw_resume_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.draw_resume_triangle(x, y, height, selected)
-    
+
     def add_sel_resume_triangle_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
+
         self.canvas.add_sel_resume_triangle(x, y, height, event)
-        
+
     def draw_completion_marker_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() - height
-        
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() - height
+
         self.canvas.draw_completion_marker(x, y, height, selected)
-    
+
     def add_sel_completion_marker_at_time(self, time, task_no, cpu_no, event):
         height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
-        
-        x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() - height
-        
+
+        x = self.get_time_xpos(time)
+        y = self.get_item_ypos(cpu_no) + self._get_bar_height() - height
+
         self.canvas.add_sel_completion_marker(x, y, height, event)
-            
+
     def draw_release_arrow_at_time(self, time, task_no, job_no=None, selected=False):
         if job_no is None and task_no is not None:
             raise ValueError("Must specify a job number along with the task number")
-            
+
         height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
+
+        x = self.get_time_xpos(time)
         y = self.origin[1] - height
-        
+
         self.canvas.draw_release_arrow_small(x, y, height, selected)
-    
+
         if task_no is not None:
             y -= GraphFormat.ARROW_LABEL_OFS
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                                           GraphFormat.DEF_FOPTS_ARROW, GraphFormat.DEF_FOPTS_ARROW_SSCRIPT, \
                                           AlignMode.CENTER, AlignMode.BOTTOM)
-    
+
     def add_sel_release_arrow_at_time(self, time, task_no, event):
         height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
+
+        x = self.get_time_xpos(time)
         y = self.origin[1] - height
-        
+
         self.canvas.add_sel_release_arrow_small(x, y, height, event)
-            
+
     def draw_deadline_arrow_at_time(self, time, task_no, job_no=None, selected=False):
         if job_no is None and task_no is not None:
             raise ValueError("Must specify a job number along with the task number")
-            
+
         height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
+
+        x = self.get_time_xpos(time)
         y = self.origin[1] - height
-        
+
         self.canvas.draw_deadline_arrow_small(x, y, height, selected)
-    
+
         if task_no is not None:
             y -= GraphFormat.ARROW_LABEL_OFS
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                                           GraphFormat.DEF_FOPTS_ARROW, GraphFormat.DEF_FOPTS_ARROW_SSCRIPT, \
                                           AlignMode.CENTER, AlignMode.BOTTOM)
-    
+
     def add_sel_deadline_arrow_at_time(self, time, task_no, event):
         height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
-        
-        x = self._get_time_xpos(time)
+
+        x = self.get_time_xpos(time)
         y = self.origin[1] - height
-        
+
         self.canvas.add_sel_deadline_arrow_small(x, y, height, event)
-        
+
     def draw_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(cpu_no)
+
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(cpu_no)
         width = self._get_bar_width(start_time, end_time)
         height = self._get_bar_height()
-        
+
         self.canvas.draw_bar(x, y, width, height, task_no, clip_side, selected)
-        
+
         # if a job number is specified, we want to draw a superscript and subscript for the task and job number, respectively
         if job_no is not None:
             x += GraphFormat.BAR_LABEL_OFS
@@ -621,37 +621,37 @@ class CpuGraph(Graph):
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                                                  GraphFormat.DEF_FOPTS_BAR, GraphFormat.DEF_FOPTS_BAR_SSCRIPT, \
                                                  AlignMode.LEFT, AlignMode.CENTER)
-    
+
     def add_sel_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(cpu_no)
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(cpu_no)
         width = self._get_bar_width(start_time, end_time)
         height = self._get_bar_height()
-        
+
         self.canvas.add_sel_bar(x, y, width, height, event)
-    
+
     def draw_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, clip_side=None, selected=False):
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-            
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(len(self.y_item_list))
+
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(len(self.y_item_list))
         width = self._get_bar_width(start_time, end_time)
         height = self._get_mini_bar_height()
-        
+
         self.canvas.draw_mini_bar(x, y, width, height, task_no, clip_side, selected)
-        
+
         if job_no is not None:
             x += GraphFormat.MINI_BAR_LABEL_OFS
             y += self.attrs.y_item_size * GraphFormat.MINI_BAR_SIZE_FACTOR / 2.0
             self.canvas.draw_label_with_sscripts('T', str(task_no), str(job_no), x, y, \
                 GraphFormat.DEF_FOPTS_MINI_BAR, GraphFormat.DEF_FOPTS_MINI_BAR_SSCRIPT, AlignMode.LEFT, AlignMode.CENTER)
-                
+
     def add_sel_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
-        x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(len(self.y_item_list))
+        x = self.get_time_xpos(start_time)
+        y = self.get_item_ypos(len(self.y_item_list))
         width = self._get_bar_width(start_time, end_time)
         height = self._get_mini_bar_height()
-        
+
         self.canvas.add_sel_mini_bar(x, y, width, height, event)