1 files changed, 109 insertions, 109 deletions

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()
-    
+