Fixes related to scrolling, along with the display of some extra information. Updated documentation.

10 files changed, 621 insertions, 370 deletions

diff --git a/doc/index.txt b/doc/index.txt
index 600590b..e24eb2a 100644
--- a/doc/index.txt
+++ b/doc/index.txt
@@ -130,6 +130,8 @@ input parameters you specify. For example, if you use `-e`
 and `-l` to specify a time range, the visualizer will
 generate a graph restricted to that time range.
 
+#### Organization of the Visualizer ####
+
 When the visualizer starts up, you'll see the beginning of the graph which the
 visualizer automatically generated. We'll first discuss the axes.
 The x-axis gives time (in whatever units
@@ -143,7 +145,11 @@ gives the identifier of a CPU that at one point was used by at least one task.
 
 The horizontal cross-section demarcated by each task name or CPU
 identifier gives the chronological sequence of events in the input stream
-for the relevant task or CPU. The event symbols are as follows:
+for the relevant task or CPU.
+
+#### Representation of Events ####
+
+The event symbols are as follows:
 
 <table border=1>
 <tr><th>Symbol Description</th><th>Event Type</th><th>Meaning</th></tr>
@@ -174,9 +180,12 @@ event occurred, but at a time not in the input stream.
 In other words, it assumes that such events are genuine. To represent this phenomenon,
 the visualizer shows the bar going "off the graph".
 
-Interacting with the visualizer is easy. The scrollbars work in the obvious way. You can also
-use the arrow keys to move, or use Ctrl+arrow keys to move faster. Mousing over an event gives
-a description of the event at the bottom. You can also click an event to
+#### Interacting with Events ####
+
+Interacting with the visualizer is easy. Mousing over an event gives
+a description of the event at the bottom, along with information about the job under which
+the event occurred.
+You can also click an event to
 select it. Hold down Ctrl to select multiple events. You can also drag a box around multiple
 events to select them. You can even combine this with the Ctrl key to select multiple
 boxes of events in succession. Your selection is independent of the mode you are in --
@@ -186,12 +195,33 @@ switch over to CPU mode. Right-click and you will get a context menu containing
 you selected. Selecting an item in the menu gives you detailed information about the event
 in its own window.
 
+#### Moving Around ####
+
+The scrollbars work in the obvious way. You can also
+use the arrow keys to move about, or use Ctrl+arrow keys to move faster.
 If you want to see what's happening at a certain time, but don't want to bother scrolling there
-manually, you can select `View->Move to Time` and type in the time you want to move to.
+manually, you can select `View->Jump to Time` and type in the time you want to move to. The
+default units are in milliseconds, but you can use an SI prefix (ns, us, ms, s) to specify
+another time unit.
 
 You can also zoom by either going to `View->Zoom In/Out`, or by holding down Ctrl and scrolling
 the mouse wheel.
 
+#### Colors ####
+
+Certain events, most notably the `Scheduled` event, are color-coded. In Task Mode, each color
+corresponds to a CPU that a job was scheduled on; conversely, in CPU Mode, each color corresponds
+to a task that a job was scheduled for. (In Task Mode, there is an extra color for a pseudo-CPU,
+CPU -1. If an event is assigned CPU -1 this simply means that there is no actual CPU that can
+logically be assigned to the event. By default, CPU -1 has a gray color.)
+
+You can change the default set of colors. To change a CPU or task color, select exactly one event
+assigned to the relevant CPU or task. Alteratively, select one of the task or CPU names listed
+in the upper-left portion of the graph. Then navigate to `Edit->Colors` and use the color chooser
+to pick the desired color.
+
+#### Exiting ####
+
 To exit the Unit-Trace visualizer, go to `File->Quit` or click the close button.
 
 ## Gotchas ##
diff --git a/temp b/temp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/temp
diff --git a/unit_trace/viz/__init__.py b/unit_trace/viz/__init__.py
index 592f697..91093c1 100644
--- a/unit_trace/viz/__init__.py
+++ b/unit_trace/viz/__init__.py
@@ -18,7 +18,7 @@ except ImportError:
 gobject.signal_new('set-scroll-adjustments', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
                         None, (gtk.Adjustment, gtk.Adjustment))
 gobject.signal_new('update-event-description', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
-                        None, (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
+                        None, (gobject.TYPE_PYOBJECT,))
 gobject.signal_new('update-sel-changes', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
                         None, (gobject.TYPE_PYOBJECT,))
 gobject.signal_new('request-context-menu', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
diff --git a/unit_trace/viz/canvas.py b/unit_trace/viz/canvas.py
index 9ac0e8b..badebe9 100644
--- a/unit_trace/viz/canvas.py
+++ b/unit_trace/viz/canvas.py
@@ -47,7 +47,7 @@ class Surface(object):
         self.virt_y = y
         self.width = width
         self.height = height
-        
+
     def set_scale(self, scale):
         """Sets the scale factor."""
         self.scale = scale
@@ -58,17 +58,21 @@ class Surface(object):
         that we should draw to. Note that these might actually be outside the
         bounds of the surface,
         if we want something outside the surface's ``window''."""
-        return (x - self.virt_x * self.scale, y - self.virt_y * self.scale)
+        return ((x - self.virt_x) * self.scale, (y - self.virt_y) * self.scale)
+
+    def get_real_dim(self, w, h):
+        """Translates virtual width and height dimensions to real width and height
+        dimensions."""
+        return (w * self.scale, h * self.scale)
 
     def get_virt_coor(self, x, y):
         """Does the inverse of the last method."""
-        return (x + self.virt_x * self.scale, y + self.virt_y * self.scale)
-
-    def get_virt_coor_unscaled(self, x, y):
-        """Does the same, but removes the scale factor (i.e. behaves as if
-        the scale was 1.0 all along)."""
         return (x / self.scale + self.virt_x, y / self.scale + self.virt_y)
 
+    def get_virt_dim(self, w, h):
+        """Does the inverse of the last method."""
+        return (w / self.scale, h / self.scale)
+
 class SVGSurface(Surface):
     def renew(self, width, height):
         iwidth = int(math.ceil(width))
@@ -77,7 +81,7 @@ class SVGSurface(Surface):
         self.height = height
         self.surface = cairo.SVGSurface(self.fname, iwidth, iheight)
         self.ctx = cairo.Context(self.surface)
-        
+
     def write_out(self, fname):
         os.execl('cp', self.fname, fname)
 
@@ -89,7 +93,7 @@ class ImageSurface(Surface):
         self.height = height
         self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, iwidth, iheight)
         self.ctx = cairo.Context(self.surface)
-        
+
     def write_out(self, fname):
         if self.surface is None:
             raise ValueError("Don't own surface, can't write to file")
@@ -98,6 +102,7 @@ class ImageSurface(Surface):
 
 class Pattern(object):
     DEF_STRIPE_SIZE = 10
+    COVER_EXTRA = 1
     MAX_FADE_WIDTH = 250
 
     def __init__(self, color_list, stripe_size=DEF_STRIPE_SIZE):
@@ -106,7 +111,7 @@ class Pattern(object):
 
     def get_color_list(self):
         return self.color_list
-        
+
     def render_on_canvas(self, canvas, x, y, width, height, fade=False):
         fade_span = min(width, Pattern.MAX_FADE_WIDTH)
 
@@ -118,7 +123,8 @@ class Pattern(object):
                 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,
+                    canvas.fill_rect(x + Pattern.MAX_FADE_WIDTH - Pattern.COVER_EXTRA, y,
+                                     width - Pattern.MAX_FADE_WIDTH + Pattern.COVER_EXTRA,
                                      height, self.color_list[0])
         else:
             n = 0
@@ -126,7 +132,7 @@ class Pattern(object):
             while y < bottom:
                 i = n % len(self.color_list)
                 if fade:
-                    canvas.fill_rect_fade(x, y, fade_span, \
+                    canvas.fill_rect_fade(x, y, fade_span,
                         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])
@@ -167,7 +173,7 @@ class Canvas(object):
 
         self.surface = surface
         self.def_surface = None
-        
+
         self.width = int(math.ceil(width))
         self.height = int(math.ceil(height))
         self.item_clist = item_clist
@@ -182,23 +188,20 @@ class Canvas(object):
         or drawing to a file."""
         if self.def_surface is not None:
             raise ValueError
-            
+
         self.def_surface = self.surface
         self.surface = surface
-        
+
     def revert_surface(self):
         """Goes back to the default surface; that is, the one used for
         drawing to the screen."""
         if self.def_surface is not None:
             self.surface = self.def_surface
             self.def_surface = None
-        
+
     def set_scale(self, scale):
         self.scale = scale
         self.surface.set_scale(scale)
-        for layer in self.selectable_regions:
-            for event in self.selectable_regions[layer]:
-                self.selectable_regions[layer][event].set_scale(scale)
 
     def scaled(self, *coors):
         """Scales a series of coordinates."""
@@ -265,7 +268,7 @@ class Canvas(object):
             self.draw_line((x, y), (x, y + GraphFormat.MAJ_TICK_SIZE),
                            (0.0, 0.0, 0.0), GraphFormat.AXIS_THICKNESS)
 
-            if (i < end_tick):
+            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)
@@ -276,7 +279,8 @@ class Canvas(object):
                         (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):
+                           unit=GraphFormat.DEF_TIME_UNIT, 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
@@ -288,9 +292,9 @@ class Canvas(object):
         minincr = incr / (min_per_maj * 1.0)
 
         cur = start * 1.0
-        
+
         for i in range(start_tick, end_tick + 1):
-            text = util.format_float(cur, 2)
+            text = util.format_float(unit.nsec_to_native(cur), 2)
             self.draw_label(text, x, y, majfopts, AlignMode.CENTER, AlignMode.TOP)
 
             if (i < end_tick):
@@ -362,7 +366,7 @@ class Canvas(object):
         y -= axis_height - item_size / 2.0 - item_size * item_no
 
         orig_color = fopts.color
-        
+
         if selected:
             fopts.color = GraphFormat.HIGHLIGHT_COLOR
         else:
@@ -370,19 +374,19 @@ class Canvas(object):
         self.draw_label(item, x, y, fopts, AlignMode.RIGHT, AlignMode.CENTER)
 
         fopts.color = orig_color
-    
+
     def add_sel_y_axis_item(self, x, y, axis_height, item, item_no, item_size, event, fopts=None):
         if fopts is None:
             fopts = GraphFormat.DEF_FOPTS_ITEM
-            
+
         x -= GraphFormat.Y_AXIS_ITEM_GAP
         y -= axis_height - item_size / 2.0 - item_size * item_no
-        
+
         x, y, width, height, f_height = self.get_label_dim(item, x, y, fopts, AlignMode.RIGHT, AlignMode.CENTER, False)
         #(x, y) gives bottom-left, not top-left
         y -= height
         self.add_sel_region(SelectableRegion(x, y, width, height, event))
-        
+
     def draw_top_item(self, x, y, axis_height, item, item_no, prev_items, selected, fopts=None):
         """Draws the item labels at the top. ``item'' is the string to print,
         while item_size gives the vertical amount of
@@ -393,22 +397,22 @@ class Canvas(object):
             fopts = GraphFormat.DEF_FOPTS_ITEM
 
         y -= axis_height + GraphFormat.TOP_ITEM_VERT_GAP
-        
+
         for prev_item in prev_items:
             x += GraphFormat.TOP_ITEM_HORIZ_GAP + self.get_label_dim(prev_item, x, y, fopts,
                                                 AlignMode.LEFT, AlignMode.TOP)[2]
-            
+
         orig_color = fopts.color
-        
+
         if selected:
             fopts.color = GraphFormat.HIGHLIGHT_COLOR
         else:
             fopts.color = self.get_bar_pattern(item_no).get_color_list()[0]
-        
+
         self.draw_label(item, x, y, fopts, AlignMode.LEFT, AlignMode.BOTTOM)
-        
+
         fopts.color = orig_color
-        
+
     def add_sel_top_item(self, x, y, axis_height, item, item_no, prev_items, event, fopts=None):
         """Draws the item labels at the top. ``item'' is the string to print,
         while item_size gives the vertical amount of
@@ -419,19 +423,19 @@ class Canvas(object):
             fopts = GraphFormat.DEF_FOPTS_ITEM
 
         y -= axis_height + GraphFormat.TOP_ITEM_VERT_GAP
-        
+
         for item in prev_items:
             x += GraphFormat.TOP_ITEM_HORIZ_GAP + self.get_label_dim(item, x, y, fopts,
                                                 AlignMode.LEFT, AlignMode.BOTTOM)[2]
-        
+
         x, y, width, height, f_height = self.get_label_dim(item, x, y, fopts, AlignMode.LEFT, AlignMode.BOTTOM, False)
         #(x, y) gives bottom-left, not top-left
         y -= height
         self.add_sel_region(SelectableRegion(x, y, width, height, event))
-        
+
     def add_sel_dummy(self, event):
         self.add_sel_region(SelectableRegion(None, None, None, None, event))
-            
+
     def add_sel_bar(self, x, y, width, height, event):
         self.add_sel_region(SelectableRegion(x, y, width, height, event))
 
@@ -593,7 +597,6 @@ class Canvas(object):
         self.selectable_regions = {}
 
     def add_sel_region(self, region):
-        region.set_scale(self.scale)
         layer = region.get_event().get_layer()
         if layer not in self.selectable_regions:
             self.selectable_regions[layer] = {}
@@ -606,9 +609,7 @@ class Canvas(object):
         return event.get_layer() in self.selectable_regions \
                and event in self.selectable_regions[event.get_layer()]
 
-    def get_intersecting_regions(self, real_x, real_y, width, height):
-        x, y = self.surface.get_virt_coor(real_x, real_y)
-
+    def get_intersecting_regions(self, x, y, width, height):
         selected = {}
         for layer in self.selectable_regions:
             for event in self.selectable_regions[layer]:
@@ -624,23 +625,23 @@ class Canvas(object):
         """Overwrites the surface completely white, but technically doesn't delete anything"""
         # Make sure we don't scale here (we want to literally white out just this region)
 
-        x, y = self.surface.get_virt_coor_unscaled(0, 0)
+        x, y = self.surface.get_virt_coor(0, 0)
         width, height = self.unscaled(self.surface.width, self.surface.height)
-        
+
         self.fill_rect(x, y, width, height, (1.0, 1.0, 1.0), False)
 
     def get_item_color(self, n):
         return self.item_clist[n]
-        
+
     def get_bar_pattern(self, n):
         return self.bar_plist[n]
-    
+
     def set_item_color(self, n, color):
         self.item_clist[n] = color
-        
+
     def set_bar_pattern(self, n, pattern):
         self.bar_plist[n] = pattern
-        
+
 class CairoCanvas(Canvas):
     """This is a basic class that stores and draws on a Cairo surface,
     using various primitives related to drawing a real-time graph (up-arrows,
@@ -672,8 +673,8 @@ class CairoCanvas(Canvas):
     def _rect_common(self, x, y, width, height, color, thickness, clip_side=None, do_snap=True):
         EXTRA_FACTOR = 2.0
 
-        x, y, width, height = self.scaled(x, y, width, height)
         x, y = self.surface.get_real_coor(x, y)
+        width, height = self.surface.get_real_dim(width, height)
         max_width = self.surface.width + EXTRA_FACTOR * thickness
         max_height = self.surface.height + EXTRA_FACTOR * thickness
 
@@ -721,8 +722,8 @@ class CairoCanvas(Canvas):
 
     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)
+        width, height = self.surface.get_real_dim(width, height)
 
         if do_snap:
             linear = cairo.LinearGradient(snap(x), snap(y), \
@@ -741,9 +742,7 @@ class CairoCanvas(Canvas):
 
     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])
         p0 = self.surface.get_real_coor(p0[0], p0[1])
-        p1 = self.scaled(p1[0], p1[1])
         p1 = self.surface.get_real_coor(p1[0], p1[1])
         if do_snap:
             p0 = (snap(p0[0]), snap(p0[1]))
@@ -756,8 +755,7 @@ class CairoCanvas(Canvas):
         self.surface.ctx.stroke()
 
     def _polyline_common(self, coor_list, color, thickness, do_snap=True):
-        scaled_coor_list = [self.scaled(coor[0], coor[1]) for coor in coor_list]
-        real_coor_list = [self.surface.get_real_coor(coor[0], coor[1]) for coor in scaled_coor_list]
+        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:
@@ -780,7 +778,7 @@ class CairoCanvas(Canvas):
 
     def _get_label_dim_common(self, text, x, y, fopts, x_bearing_factor, \
                            f_descent_factor, width_factor, f_height_factor,
-                           scale, do_snap=True):
+                           do_snap=True):
         """Helper function for drawing a label with some alignment. Instead of taking in an alignment,
         it takes in the scale factor for the font extent parameters, which give the raw data of how much to adjust
         the x and y parameters. Only should be used internally."""
@@ -793,30 +791,30 @@ class CairoCanvas(Canvas):
             surface.renew(10, 10)
         else:
             surface = self.surface
-                
+
         surface.ctx.select_font_face(fopts.name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
-        surface.ctx.set_font_size(fopts.size * scale)
+        surface.ctx.set_font_size(fopts.size)
 
         fe = surface.ctx.font_extents()
         f_ascent, f_descent, f_height = fe[:3]
 
         te = surface.ctx.text_extents(text)
         x_bearing, y_bearing, width, height = te[:4]
-        
+
         actual_x = x - x_bearing * x_bearing_factor - width * width_factor
         actual_y = y - f_descent * f_descent_factor + f_height * f_height_factor
 
         if do_snap:
             actual_x = snap(actual_x)
             actual_y = snap(actual_y)
-        
+
         return actual_x, actual_y, width, height, f_height
 
     def get_label_dim(self, text, x, y, fopts=GraphFormat.DEF_FOPTS_LABEL, halign=AlignMode.LEFT,
-                      valign=AlignMode.BOTTOM, do_scale=True, do_snap=True):
+                      valign=AlignMode.BOTTOM, do_snap=True):
         """Gets the dimensions of the label if it were to be drawn with the given parameters, and with the given
         justification. Note: this does everything except actually draw the label"""
-        
+
         x_bearing_factor, f_descent_factor, width_factor, f_height_factor = 0.0, 0.0, 0.0, 0.0
         halign_factors = {AlignMode.LEFT : (0.0, 0.0), AlignMode.CENTER : (1.0, 0.5), AlignMode.RIGHT : (1.0, 1.0)}
         if halign not in halign_factors:
@@ -827,24 +825,22 @@ class CairoCanvas(Canvas):
         if valign not in valign_factors:
             raise ValueError('Invalid alignment value')
         f_descent_factor, f_height_factor = valign_factors[valign]
-        
-        scale = 1.0
-        if do_scale:
-            scale = self.scale
-            
+
         return self._get_label_dim_common(text, x, y, fopts, x_bearing_factor,
                                           f_descent_factor, width_factor, f_height_factor,
-                                          scale, do_snap)
-        
+                                          do_snap)
+
     def draw_label(self, text, x, y, fopts=GraphFormat.DEF_FOPTS_LABEL, halign=AlignMode.LEFT, valign=AlignMode.BOTTOM, do_snap=True):
         """Draws a label with the given parameters, with the given horizontal and vertical justification."""
-        
-        x, y = self.scaled(x, y)
-        actual_x, actual_y, width, height, f_height = self.get_label_dim(text, x, y, fopts, halign, valign, True, do_snap)
+
+        actual_x, actual_y, width, height, f_height = self.get_label_dim(text, x, y, fopts, halign, valign, do_snap)
         actual_x, actual_y = self.surface.get_real_coor(actual_x, actual_y)
-        
+
+        self.surface.ctx.select_font_face(fopts.name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
+        self.surface.ctx.set_font_size(fopts.size * self.scale)
         self.surface.ctx.set_source_rgb(fopts.color[0], fopts.color[1], fopts.color[2])
         self.surface.ctx.move_to(actual_x, actual_y)
+
         self.surface.ctx.show_text(text)
 
     def draw_label_with_sscripts(self, text, supscript, subscript, x, y, \
@@ -881,7 +877,7 @@ def snap(pos):
     since the line will get distributed over two pixels. We actually apply this to all
     coordinates to make sure everything is aligned."""
     return pos - 0.5
-    
+
 # represents a selectable region of the graph
 class SelectableRegion(object):
     def __init__(self, x, y, width, height, event):
@@ -892,7 +888,6 @@ class SelectableRegion(object):
         self.width = width
         self.height = height
         self.event = event
-        self.scale = 1.0
 
     def get_dimensions(self):
         """Gets the dimensions of the region."""
@@ -902,18 +897,15 @@ class SelectableRegion(object):
         """Gets the event associated with the region."""
         return self.event
 
-    def set_scale(self, scale):
-        self.scale = scale
-
     def is_dummy(self):
         return self.x is None or self.y is None
-        
+
     def intersects(self, x, y, width, height):
         if self.is_dummy():
             return False
-            
-        return x <= (self.x + self.width) * self.scale \
-           and x + width >= self.x * self.scale \
-           and y <= (self.y + self.height) * self.scale \
-           and y + height >= self.y * self.scale
+
+        return x <= (self.x + self.width) \
+           and x + width >= self.x \
+           and y <= (self.y + self.height) \
+           and y + height >= self.y
 
diff --git a/unit_trace/viz/format.py b/unit_trace/viz/format.py
index 18dfd5a..13d4843 100644
--- a/unit_trace/viz/format.py
+++ b/unit_trace/viz/format.py
@@ -1,5 +1,7 @@
 """Various formatting parameters intended to be accessible by the client."""
 
+import util
+
 class FontOptions(object):
     """Class for combining assorted simple font options."""
     def __init__(self, name, size, color):
@@ -58,6 +60,8 @@ class GraphFormat(object):
     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))
 
+    DEF_TIME_UNIT = util.MilliSec()
+
     LEFT_SIDE_PAD = 30
     WIDTH_PAD = 50
     HEIGHT_PAD = 150
@@ -85,7 +89,7 @@ class GraphFormat(object):
     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,
-    minfopts=DEF_FOPTS_MIN):
+    minfopts=DEF_FOPTS_MIN, unit=DEF_TIME_UNIT):
         self.time_per_maj = time_per_maj
         self.maj_sep = maj_sep
         self.min_per_maj = min_per_maj
@@ -95,3 +99,4 @@ class GraphFormat(object):
         self.show_min = show_min
         self.majfopts = majfopts
         self.minfopts = minfopts
+        self.unit = unit
diff --git a/unit_trace/viz/graph.py b/unit_trace/viz/graph.py
index fa0df99..73c4ce4 100644
--- a/unit_trace/viz/graph.py
+++ b/unit_trace/viz/graph.py
@@ -60,25 +60,25 @@ class Graph(object):
 
         #if surface.ctx is None:
         #    surface.renew(width, height)
-        
-        # item clist might end before 
+
+        # item clist might end before
         full_item_clist = []
         full_bar_plist = []
-        
+
         for i in range(0, len(self.y_item_list)):
             full_item_clist.append(item_clist[i % len(item_clist)])
-        
+
         for i in range(0, len(self.top_item_list)):
             full_bar_plist.append(bar_plist[i % (len(bar_plist) - 1)])
-            
+
         # last bar pattern is a ``special pattern'' so put it at
-        # the end (and nowhere else)    
+        # the end (and nowhere else)
         full_bar_plist.append(bar_plist[-1])
-        
+
         self.canvas = CanvasType(width, height, full_item_clist, full_bar_plist, surface)
 
-    def get_intersecting_regions(self, real_x, real_y, width, height):
-        return self.canvas.get_intersecting_regions(real_x, real_y, width, height)
+    def get_intersecting_regions(self, x, y, width, height):
+        return self.canvas.get_intersecting_regions(x, y, width, height)
 
     def get_width(self):
         return self.width
@@ -103,29 +103,55 @@ class Graph(object):
 
     def get_item_color(self, no):
         return self.canvas.get_item_color(no)
-        
+
     def get_bar_pattern(self, no):
         return self.canvas.get_bar_pattern(no)
-    
+
     def set_bar_pattern(self, no, pattern):
         self.canvas.set_bar_pattern(no, pattern)
-        
-    def update_view(self, x, y, width, height, scale, ctx):
-        """Updates the view's window location, scale factor, and Cairo context (i.e. where
+
+    def real_to_virt(self, x, y, width, height):
+        """Convert real coordinates to virtual coordinates."""
+        virt_x, virt_y = self.canvas.surface.get_virt_coor(x, y)
+        virt_width, virt_height = self.canvas.surface.get_virt_dim(width, height)
+        return (virt_x, virt_y, virt_width, virt_height)
+
+    def real_to_virt_list(self, coors):
+        l = []
+        for coor in coors:
+            l.append(self.real_to_virt(coor[0], coor[1], coor[2], coor[3]))
+        return l
+
+    def virt_to_real(self, x, y, width, height):
+        real_x, real_y = self.canvas.surface.get_real_coor(x, y)
+        real_width, real_height = self.canvas.surface.get_real_dim(width, height)
+        return (real_x, real_y, real_width, real_height)
+
+    def virt_to_real_list(self, coors):
+        l = []
+        for coor in coors:
+            l.append(self.virt_to_real(coor[0], coor[1], coor[2], coor[3]))
+        return l
+
+    def update_view(self, x, y, width, height, scale):
+        """Updates the view's window location and scale factor, and Cairo context (i.e. where
         the view currently ``is'')."""
         self.canvas.surface.pan(x, y, width, height)
         self.canvas.set_scale(scale)
+
+    def load_ctx(self, ctx):
+        """Borrows a context to draw on."""
         self.canvas.surface.change_ctx(ctx)
 
     def set_tmp_surface(self, surface):
         """Changes to a temporary surface, instead of using the default surface (the
         surface that writes to the screen."""
         self.canvas.set_tmp_surface(surface)
-    
+
     def revert_surface(self):
         """Changes back to the default surface."""
         self.canvas.revert_surface()
-        
+
     def _recomp_min_max(self, start_time, end_time, start_item, end_item):
         if self.min_time is None or start_time < self.min_time:
             self.min_time = start_time
@@ -177,15 +203,12 @@ class Graph(object):
     def ycoor_to_item_no(self, y):
         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)
+    def get_offset_params(self, x, y, width, height):
+        start_time = self.xcoor_to_time(x)
+        end_time = self.xcoor_to_time(x + width)
 
-        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)
+        start_item = self.ycoor_to_item_no(y)
+        end_item = 1 + self.ycoor_to_item_no(y + height)
 
         return (start_time, end_time, start_item, end_item)
 
@@ -199,7 +222,7 @@ class Graph(object):
         self.canvas.whiteout()
         start, end = sched.get_time_bounds()
         self.draw_skeleton(start, end, 0, len(self.y_item_list))
-        
+
         slots = {}
         all_events = {}
         sched.get_time_slot_array().get_slots(slots,
@@ -210,7 +233,7 @@ class Graph(object):
             if event.get_layer() not in all_events:
                 all_events[event.get_layer()] = {}
             all_events[event.get_layer()][event] = None
-                    
+
         self.render_events(all_events)
 
     def get_events_to_render(self, sched, regions, selectable=False):
@@ -221,15 +244,15 @@ class Graph(object):
             x, y, width, height = region
             start_time, end_time, start_item, end_item = self.get_offset_params(x, y, width, height)
             self._recomp_min_max(start_time, end_time, start_item, end_item)
-            
+
             sched.get_time_slot_array().get_slots(slots,
                         start_time, end_time, start_item, end_item,
                         self.list_type)
-        
+
         events_to_render = {}
         for layer in Canvas.LAYERS:
             events_to_render[layer] = {}
-        
+
         for event in sched.get_time_slot_array().get_events(slots,
                 self.list_type, schedule.EVENT_LIST):
             events_to_render[event.get_layer()][event] = None
@@ -246,7 +269,7 @@ class Graph(object):
             self.draw_skeleton(self.min_time, self.max_time,
                                self.min_item, self.max_item)
         self.render_events(events, selectable)
-                               
+
     def render_events(self, events, selectable=False):
         for layer in Canvas.LAYERS:
             prev_events = {}
@@ -278,7 +301,7 @@ class Graph(object):
         self.canvas.draw_grid(self.origin[0], self.origin[1], self._get_y_axis_height(),
                               start_tick, end_tick, start_item, end_item, self.attrs.maj_sep, self.attrs.y_item_size, \
                               self.attrs.min_per_maj, True)
-        
+
     def draw_x_axis_with_labels_at_time(self, start_time, end_time):
         start_tick = max(0, self._get_bottom_tick(start_time))
         end_tick = min(self.num_maj - 1, self._get_top_tick(end_time))
@@ -288,33 +311,33 @@ class Graph(object):
         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)
+                                self.attrs.time_per_maj, False, self.attrs.unit)
 
     def draw_y_axis(self):
         self.canvas.draw_y_axis(self.origin[0], self.origin[1], self._get_y_axis_height())
         #self.canvas.draw_y_axis_labels(self.origin[0], self.origin[1], self._get_y_axis_height(), \
         #                               self.y_item_list, self.attrs.y_item_size)
-        
+
     def draw_y_axis_item(self, item_no, selected):
         self.canvas.draw_y_axis_item(self.origin[0], self.origin[1], self._get_y_axis_height(),
                                         self.y_item_list[item_no], item_no, self.attrs.y_item_size,
                                         selected)
-    
+
     def add_sel_y_axis_item(self, item_no, event):
         self.canvas.add_sel_y_axis_item(self.origin[0], self.origin[1], self._get_y_axis_height(),
                                         self.y_item_list[item_no], item_no, self.attrs.y_item_size,
                                         event)
-    
+
     def draw_top_item(self, item_no, selected):
         self.canvas.draw_top_item(self.origin[0], self.origin[1], self._get_y_axis_height(),
                                         self.top_item_list[item_no], item_no, self.top_item_list[0:item_no],
                                         selected)
-    
+
     def add_sel_top_item(self, item_no, event):
         self.canvas.add_sel_top_item(self.origin[0], self.origin[1], self._get_y_axis_height(),
                                         self.top_item_list[item_no], item_no, self.top_item_list[0:item_no],
                                         event)
-                                        
+
     def all_one_item_selected(self, selected):
         """When the user selects some parts of the graph, it might be the case that all of the
         parts lie under one ``item'' of the graph. In this case, certain operations are likely
@@ -322,19 +345,19 @@ class Graph(object):
         a set of selected items satisfies this criterion. It also gives the item selected if
         so."""
         raise NotImplementedError
-        
+
     def draw_cpu_item(self, item_no, selected):
         raise NotImplementedError
-        
+
     def add_sel_cpu_item(self, item_no, event):
         raise NotImplementedError
-        
+
     def draw_task_item(self, item_no, selected):
         raise NotImplementedError
-        
+
     def add_sel_task_item(self, item_no, event):
         raise NotImplementedError
-            
+
     def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         """Draws a suspension symbol for a dcertain task at an instant in time."""
         raise NotImplementedError
@@ -404,7 +427,7 @@ class TaskGraph(Graph):
         super(TaskGraph, self).__init__(CanvasType, surface, start_time, end_time, y_item_list, top_item_list,
                                         attrs, item_clist, bar_plist)
         self.list_type = schedule.TimeSlotArray.TASK_LIST
-        
+
     def all_one_item_selected(self, selected):
         cpu = None
         for layer in selected:
@@ -414,21 +437,21 @@ class TaskGraph(Graph):
                 else:
                     if event.get_cpu() is None or event.get_cpu() != cpu:
                         return None
-                        
+
         return cpu
-        
+
     def draw_cpu_item(self, item_no, selected):
         self.draw_top_item(item_no, selected)
-        
+
     def add_sel_cpu_item(self, item_no, event):
         self.add_sel_top_item(item_no, event)
-        
+
     def draw_task_item(self, item_no, selected):
         self.draw_y_axis_item(item_no, selected)
-        
+
     def add_sel_task_item(self, item_no, event):
         self.add_sel_y_axis_item(item_no, event)
-        
+
     def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
         x = self.get_time_xpos(time)
@@ -563,7 +586,7 @@ class CpuGraph(Graph):
         super(CpuGraph, self).__init__(CanvasType, surface, start_time, end_time, y_item_list, top_item_list,
                                         attrs, item_clist, bar_plist)
         self.list_type = schedule.TimeSlotArray.CPU_LIST
-        
+
     def all_one_item_selected(self, selected):
         task_no = None
         for layer in selected:
@@ -573,21 +596,21 @@ class CpuGraph(Graph):
                 else:
                     if event.get_task() is None or event.get_task().get_task_no() != task_no:
                         return None
-                        
+
         return task_no
-            
+
     def draw_cpu_item(self, item_no, selected):
         self.draw_y_axis_item(item_no, selected)
-        
+
     def add_sel_cpu_item(self, item_no, event):
         self.add_sel_y_axis_item(item_no, event)
-        
+
     def draw_task_item(self, item_no, selected):
         self.draw_top_item(item_no, selected)
-        
+
     def add_sel_task_item(self, item_no, event):
         self.add_sel_top_item(item_no, event)
-        
+
     def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
         x = self.get_time_xpos(time)
diff --git a/unit_trace/viz/schedule.py b/unit_trace/viz/schedule.py
index 82b7ea1..ec6398d 100644
--- a/unit_trace/viz/schedule.py
+++ b/unit_trace/viz/schedule.py
@@ -22,14 +22,14 @@ class TimeSlotArray(object):
     TASK_LIST = 0
     CPU_LIST = 1
     LIST_TYPES = (TASK_LIST, CPU_LIST)
-    
+
     PRE_ITEM_NO = -1
     POST_ITEM_NO = -2
-    
+
     PRE_SLOT = 'pre'
     POST_SLOT = 'post'
     ALL_SLOT = 'all'
-    
+
     def __init__(self, time_per_maj=None, num_tasks=0, num_cpus=0):
         if time_per_maj is None:
             self.array = None
@@ -40,7 +40,7 @@ class TimeSlotArray(object):
         self.array = {}
         self.min_slot = None
         self.max_slot = None
-        
+
         for type in self.list_sizes:
             num = self.list_sizes[type]
             self.array[type] = []
@@ -53,12 +53,12 @@ class TimeSlotArray(object):
 
     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)
-        
+
         if self.min_slot is None or slot < self.min_slot:
             self.min_slot = slot
         if self.max_slot is None or slot > self.max_slot:
@@ -69,10 +69,10 @@ class TimeSlotArray(object):
         cpu = event.get_cpu()
 
         slot = self.get_time_slot(event.get_time())
-        
+
         for type in item_nos:
             self.put_event_in_slot(type, item_nos[type], event.__class__, slot, event)
-    
+
     def fill_span_event_from_start(self, event, item_nos):
         end_slot = None
         if event.corresp_end_event is None:
@@ -104,17 +104,17 @@ class TimeSlotArray(object):
 
             for type in item_nos:
                 self.put_event_in_slot(type, item_nos[type], event.dummy_class, slot, dummy)
-                        
+
     def add_item_dummies(self, sched):
         start = sched.get_time_bounds()[0]
-        
+
         for task in sched.get_tasks().values():
             dummy = TaskDummy(start, task)
             self.put_event_in_slot(TimeSlotArray.TASK_LIST, task.get_task_no(), dummy.__class__,
                                         TimeSlotArray.PRE_SLOT, dummy)
             self.put_event_in_slot(TimeSlotArray.CPU_LIST, TimeSlotArray.PRE_ITEM_NO, dummy.__class__,
                                         TimeSlotArray.ALL_SLOT, dummy)
-                                        
+
         for i in range(0, self.list_sizes[TimeSlotArray.CPU_LIST]):
             dummy = CPUDummy(start, sched, i)
             self.put_event_in_slot(TimeSlotArray.CPU_LIST, i, dummy.__class__,
@@ -135,14 +135,14 @@ class TimeSlotArray(object):
             raise ValueError('Litmus is not a time machine')
         if start_no > end_no:
             raise ValueError('start no should be less than end no')
-    
+
         if self.min_slot is None:
             # no events ever got added
             return {}
-            
+
         start_slot = self.get_time_slot(start)
         end_slot = self.get_time_slot(end) + 1
-        
+
         item_no_list = []
         if start_no < 0:
             item_no_list.append(TimeSlotArray.PRE_ITEM_NO)
@@ -151,24 +151,24 @@ class TimeSlotArray(object):
         start_no = max(0, start_no)
         end_no = min(self.list_sizes[list_type] - 1, end_no)
         item_no_list += range(start_no, end_no + 1)
-        
+
         edge_slots = [TimeSlotArray.ALL_SLOT]
         if start_slot <= self.min_slot:
             edge_slots.append(TimeSlotArray.PRE_SLOT)
         if end_slot >= self.max_slot:
             edge_slots.append(TimeSlotArray.POST_SLOT)
-        
+
         for slot in edge_slots:
             slots[slot] = {}
             for no in item_no_list:
                 slots[slot][no] = None
-        
+
         for slot in xrange(start_slot, end_slot + 1):
             if slot not in slots:
                 slots[slot] = {}
             for no in item_no_list:
                 slots[slot][no] = None
-                
+
 class Schedule(object):
     """The total schedule (task system), consisting of a certain number of
     tasks."""
@@ -213,8 +213,8 @@ class Schedule(object):
             self.time_slot_array = TimeSlotArray()
             return
 
-        self.time_slot_array = TimeSlotArray(self.time_per_maj, \
-                                                 len(self.task_list), self.num_cpus)
+        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
@@ -226,6 +226,7 @@ class Schedule(object):
         self.start = None
         self.end = None
 
+        self.sort_task_nos_numeric()
         self.set_time_params(time_per_maj)
 
         # we scan the graph task by task, and job by job
@@ -250,10 +251,10 @@ class Schedule(object):
                 switch_event = switches[event]
                 if switch_event is not None:
                     event.fill_span_event_from_start()
-    
+
         # add events that correspond to the tasks and CPUS, at the very beginning
         self.time_slot_array.add_item_dummies(self)
-        
+
     def add_task(self, task):
         if task.name in self.tasks:
             raise ValueError("task already in list!")
@@ -263,6 +264,17 @@ class Schedule(object):
         task.task_no = self.cur_task_no
         self.cur_task_no += 1
 
+    def sort_task_nos_numeric(self):
+        # sort task numbers by the numeric value of the task names.
+        nums = []
+
+        for task_name in self.tasks:
+            nums.append((int(task_name), task_name))
+
+        nums.sort(key=lambda t: t[0])
+        for no, task in enumerate(nums):
+            self.tasks[task[1]].task_no = no
+
     def get_tasks(self):
         return self.tasks
 
@@ -281,6 +293,11 @@ def deepcopy_selected(selected):
         selected_copy[layer] = copy.copy(selected[layer])
     return selected_copy
 
+def _format_time(time, unit):
+    if time is None:
+        return '(None)'
+    return util.format_float(unit.nsec_to_native(time), Event.NUM_DEC_PLACES) \
+                             + ' ' + str(unit)
 class Task(object):
     """Represents a task, including the set of jobs that were run under
     this task."""
@@ -317,15 +334,75 @@ class Job(object):
         self.job_no = job_no
         self.events = {}
         self.task = None
+        self.start_run_time = None
+        self.end_run_time = None
+        self.release_time = None
+        self.deadline_time = None
         for event in event_list:
             self.add_event(event)
 
+    def get_name(self):
+        return 'Job ' + str(self.job_no) + ' for task ' + str(self.get_task().get_task_no())
+
+    def str_long(self, unit):
+        duration = None
+        if self.start_run_time is not None and self.end_run_time is not None:
+            duration = self.end_run_time - self.start_run_time
+
+        return_str = 'Job Information\n---------------' + \
+                '\nTask Name: ' + str(self.get_task().get_name()) + \
+                '\n(Task no., Job no.): ' + str((self.get_task().get_task_no(), \
+                                                self.get_job_no())) + \
+                '\nStart Run Time: ' + _format_time(self.start_run_time, unit)
+
+        if duration is not None:
+            return_str += '\nDuration: ' + _format_time(duration, unit)
+
+        return_str += '\nEnd Run Time: ' + _format_time(self.end_run_time, unit) \
+                    + '\nRelease Time: ' + _format_time(self.release_time, unit) \
+                    + '\nDeadline Time: ' + _format_time(self.deadline_time, unit)
+
+        return return_str
+
+    def str_run_short(self, unit):
+        start = self.start_run_time
+        end = self.end_run_time
+        duration = None
+        if start is not None and end is not None:
+            duration = end - start
+
+        return_str = self.get_name() + ': START=' + _format_time(start, unit)
+
+        if duration is not None:
+            return_str += ', DUR=' + _format_time(duration, unit)
+
+        return_str += ', END=' + _format_time(end, unit)
+
+        return return_str
+
+    def str_rd_short(self, unit):
+        return self.get_name() + ': RELEASE=' + _format_time(self.release_time, unit) \
+               + ', DEADLINE=' + _format_time(self.deadline_time, unit)
+
     def add_event(self, event):
         if event.time not in self.events:
-            self.events[event.time] = []
-        self.events[event.time].append(event)
+            self.events[event.get_time()] = []
+        self.events[event.get_time()].append(event)
         event.job = self
 
+        # update some statistics
+        if isinstance(event, ReleaseEvent):
+            if self.release_time is None or event.get_time() < self.release_time:
+                self.release_time = event.get_time()
+        elif isinstance(event, DeadlineEvent):
+            if self.deadline_time is None or event.get_time() > self.deadline_time:
+                self.deadline_time = event.get_time()
+        else:
+            if self.start_run_time is None or event.get_time() < self.start_run_time:
+                self.start_run_time = event.get_time()
+            if self.end_run_time is None or event.get_time() > self.end_run_time:
+                self.end_run_time = event.get_time()
+
     def get_events(self):
         return self.events
 
@@ -348,9 +425,6 @@ class DummyEvent(object):
         self.job = None
         self.layer = None
 
-    def __str__(self):
-        return '[Dummy Event]'
-
     def get_time(self):
         return self.time
 
@@ -359,21 +433,21 @@ class DummyEvent(object):
 
     def get_schedule(self):
         return self.get_task().get_schedule()
-    
+
     def get_task(self):
         return self.get_job().get_task()
-            
+
     def get_job(self):
         return self.job
 
     def get_layer(self):
         return self.layer
-    
+
     def is_selected(self):
         """Returns whether the event has been selected by the user. (needed for rendering)"""
         selected = self.get_schedule().get_selected()
         return self.get_layer() in selected and self in selected[self.get_layer()]
-        
+
     def render(self, graph, layer, prev_events, selectable=False):
         """Method that the visualizer calls to tell the event to render itself
         Obviously only implemented by subclasses (actual event types)
@@ -396,17 +470,21 @@ class Event(DummyEvent):
     def get_name(self):
         raise NotImplementedError
 
-    def __str__(self):
-        return self.get_name() + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
+    def str_short(self, unit):
+        return self.get_name() + self._common_str() + ', TIME=' + \
+               util.format_float(unit.nsec_to_native(self.get_time()), Event.NUM_DEC_PLACES) + \
+               ' ' + str(unit)
 
-    def str_long(self):
+    def str_long(self, unit):
         """Prints the event as a string, in ``long'' form."""
-        return 'Event Type: ' + self.get_name() + \
+        return 'Event Information\n-----------------\n' + \
+                'Event Type: ' + self.get_name() + \
                 '\nTask Name: ' + str(self.get_job().get_task().get_name()) + \
                 '\n(Task no., Job no.): ' + str((self.get_job().get_task().get_task_no(), \
                                                 self.get_job().get_job_no())) + \
                 '\nCPU: ' + str(self.get_cpu()) + \
-                '\nTime: ' + str(self.get_time())
+                '\nTime: ' + _format_time(self.get_time(), unit) + \
+                '\n\n' + self.get_job().str_long(unit)
 
     def _common_str(self):
         job = self.get_job()
@@ -440,7 +518,7 @@ class Event(DummyEvent):
                          TimeSlotArray.CPU_LIST : self.get_cpu() }
         sched.get_time_slot_array().add_event_to_time_slot(self, item_nos)
         self.fill_span_event_from_end()
-    
+
     def fill_span_event_from_start(self):
         """This method exists for events that can ``range'' over a period of time
         (e.g. SwitchAway and SwitchTo). In case a start event is not paired with
@@ -448,11 +526,11 @@ class Event(DummyEvent):
         the way to the beginning or end. Since most events occur only at a specific
         time, this is usually a no-op."""
         pass
-        
+
     def fill_span_event_from_end(self):
         """The mirror image of the last method."""
         pass
-        
+
 class SpanEvent(Event):
     def __init__(self, time, cpu, dummy_class):
         super(SpanEvent, self).__init__(time, cpu)
@@ -461,54 +539,93 @@ class SpanEvent(Event):
 class SpanDummy(DummyEvent):
     def __init__(self):
         super(SpanDummy, self).__init__(None, None)
-    
+
     def get_task(self):
         if self.corresp_start_event is not None:
             return self.corresp_start_event.get_task()
         if self.corresp_end_event is not None:
             return self.corresp_end_event.get_task()
         return None
-        
+
     def get_schedule(self):
         if self.corresp_start_event is not None:
             return self.corresp_start_event.get_schedule()
         if self.corresp_end_event is not None:
             return self.corresp_end_event.get_schedule()
         return None
-    
+
     def get_job(self):
         if self.corresp_start_event is not None:
             return self.corresp_start_event.get_job()
         if self.corresp_end_event is not None:
             return self.corresp_end_event.get_job()
         return None
-    
+
     def get_cpu(self):
         if self.corresp_start_event is not None:
             return self.corresp_start_event.get_cpu()
         if self.corresp_end_event is not None:
             return self.corresp_end_event.get_cpu()
         return None
-        
+
     def get_time(self):
         if self.corresp_start_event is not None:
             return self.corresp_start_event.get_time()
         if self.corresp_end_event is not None:
             return self.corresp_end_event.get_time()
         return None
-            
+
 class StartSpanEvent(SpanEvent):
+    def str_short(self, unit):
+        if self.corresp_end_event is None:
+            return super(StartSpanEvent, self).str_short(unit)
+        start = self.get_time()
+        end = self.corresp_end_event.get_time()
+        duration = end - start
+        return self.get_name() + self._common_str() + ', START=' \
+               + _format_time(start, unit) \
+               + ', DUR=' + _format_time(duration, unit) \
+               + ', END=' + _format_time(end, unit)
+
+    def str_long(self, unit):
+        if self.corresp_end_event is None:
+            return super(StartSpanEvent, self).str_long(unit)
+        else:
+            start = self.get_time()
+            end = self.corresp_end_event.get_time()
+            duration = end - start
+            return 'Event Type: ' + self.get_name() + \
+                '\nTask Name: ' + str(self.get_job().get_task().get_name()) + \
+                '\n(Task no., Job no.): ' + str((self.get_job().get_task().get_task_no(), \
+                                                self.get_job().get_job_no())) + \
+                '\nCPU: ' + str(self.get_cpu()) + \
+                '\nStart: ' + _format_time(start, unit) + \
+                '\nDuration: ' + _format_time(duration, unit) + \
+                '\nEnd: ' + _format_time(end, unit) + \
+                '\n\n' + self.get_job().str_long(unit)
+
     def fill_span_event_from_start(self):
         item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
                      TimeSlotArray.CPU_LIST : self.get_cpu() }
         self.get_schedule().get_time_slot_array().fill_span_event_from_start(self, item_nos)
 
 class EndSpanEvent(SpanEvent):
+    def str_short(self, unit):
+        if self.corresp_start_event is None:
+            return super(EndSpanEvent, self).str_short(unit)
+        return self.corresp_start_event.str_short(unit)
+
+    def str_long(self, unit):
+        if self.corresp_start_event is None:
+            return super(EndSpanEvent, self).str_long(unit)
+        else:
+            return self.corresp_start_event.str_long(unit)
+
     def fill_span_event_from_end(self):
         item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
                      TimeSlotArray.CPU_LIST : self.get_cpu() }
         self.get_schedule().get_time_slot_array().fill_span_event_from_end(self, item_nos)
-                
+
 class SuspendEvent(Event):
     def __init__(self, time, cpu):
         super(SuspendEvent, self).__init__(time, cpu)
@@ -592,25 +709,6 @@ class SwitchToEvent(StartSpanEvent):
         else:
             return 'Scheduled'
 
-    def __str__(self):
-        if self.corresp_end_event is None:
-            return super(SwitchToEvent, self).__str__()
-        return self.get_name() + 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 str_long(self):
-        if self.corresp_end_event is None:
-            return super(SwitchToEvent, self).str_long()
-        else :
-            return 'Event Type: ' + self.get_name() + \
-                '\nTask Name: ' + str(self.get_job().get_task().get_name()) + \
-                '\n(Task no., Job no.): ' + str((self.get_job().get_task().get_task_no(), \
-                                                self.get_job().get_job_no())) + \
-                '\nCPU: ' + str(self.get_cpu()) + \
-                '\nStart: ' + str(self.get_time()) + \
-                '\nEnd: ' + str(self.corresp_end_event.get_time())
-
     def scan(self, cur_cpu, switches):
         old_cur_cpu = cur_cpu[0]
         cur_cpu[0] = self.get_cpu()
@@ -656,17 +754,6 @@ class SwitchAwayEvent(EndSpanEvent):
         else:
             return 'Scheduled'
 
-    def __str__(self):
-        if self.corresp_start_event is None:
-            return super(SwitchAwayEvent, self).__str__()
-        return str(self.corresp_start_event)
-
-    def str_long(self):
-        if self.corresp_start_event is None:
-            return super(SwitchAwayEvent, self).str_long()
-
-        return self.corresp_start_event.str_long()
-
     def scan(self, cur_cpu, switches):
         old_cur_cpu = cur_cpu[0]
 
@@ -772,30 +859,11 @@ class InversionStartEvent(StartSpanEvent):
         else:
             return 'Priority Inversion'
 
-    def __str__(self):
-        if self.corresp_end_event is None:
-            return super(InversionStartEvent, self).__str__()
-        return self.get_name() + 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 str_long(self):
-        if self.corresp_end_event is None:
-            return super(InversionStartEvent, self).str_long()
-        else :
-            return 'Event Type: ' + self.get_name() + \
-                '\nTask Name: ' + str(self.get_job().get_task().get_name()) + \
-                '\n(Task no., Job no.): ' + str((self.get_job().get_task().get_task_no(), \
-                                                self.get_job().get_job_no())) + \
-                '\nCPU: ' + str(self.get_cpu()) + \
-                '\nStart: ' + str(self.get_time()) + \
-                '\nEnd: ' + str(self.corresp_end_event.get_time())
-    
     def fill_span_event_from_start(self):
         item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
                      TimeSlotArray.CPU_LIST : TimeSlotArray.POST_ITEM_NO }
         self.get_schedule().get_time_slot_array().fill_span_event_from_start(self, item_nos)
-        
+
     def scan(self, cur_cpu, switches):
         switches[InversionStartEvent] = self
         self.corresp_end_event = None
@@ -840,23 +908,11 @@ class InversionEndEvent(EndSpanEvent):
         else:
             return 'Priority Inversion'
 
-    def __str__(self):
-        if self.corresp_start_event is None:
-            return super(InversionEndEvent, self).__str__()
-
-        return str(self.corresp_start_event)
-
-    def str_long(self):
-        if self.corresp_start_event is None:
-            return super(InversionEndEvent, self).str_long()
-
-        return self.corresp_start_event.str_long()
-
     def fill_span_event_from_end(self):
         item_nos = { TimeSlotArray.TASK_LIST : self.get_task().get_task_no(),
                      TimeSlotArray.CPU_LIST : TimeSlotArray.POST_ITEM_NO }
         self.get_schedule().get_time_slot_array().fill_span_event_from_end(self, item_nos)
-        
+
     def scan(self, cur_cpu, switches):
         self.corresp_start_event = switches[InversionStartEvent]
 
@@ -932,25 +988,25 @@ class TaskDummy(DummyEvent):
         super(TaskDummy, self).__init__(time, None)
         self.task = task
         self.layer = Canvas.BOTTOM_LAYER
-        
+
     def get_name(self):
         return 'Task'
-        
-    def __str__(self):
+
+    def str_short(self, unit):
         return 'Task ' + self.task.get_name()
 
-    def str_long(self):
+    def str_long(self, unit):
         return 'Task ' + self.task.get_name()
-    
+
     def get_task(self):
         return self.task
-                        
+
     def render(self, graph, layer, prev_events, selectable=False):
         if selectable:
             graph.add_sel_task_item(self.task.get_task_no(), self)
         else:
             graph.draw_task_item(self.task.get_task_no(), self.is_selected())
-    
+
 class CPUDummy(DummyEvent):
     """A dummy event that represents a certain CPU. Used for rendering the CPU's ``name''
     (i.e. ``CPU #n'')"""
@@ -958,29 +1014,29 @@ class CPUDummy(DummyEvent):
         super(CPUDummy, self).__init__(time, cpu)
         self.sched = sched
         self.layer = Canvas.BOTTOM_LAYER
-        
+
     def get_name(self):
         return 'CPU'
-        
-    def __str__(self):
+
+    def str_short(self, unit):
         return 'CPU #' + str(self.get_cpu())
 
-    def str_long(self):
+    def str_long(self, unit):
         return 'CPU #' + str(self.get_cpu())
-    
+
     def get_task(self):
         return None
-        
+
     def get_schedule(self):
         # we don't have a job, so get the schedule from the schedule passed in
         return self.sched
-            
+
     def render(self, graph, layer, prev_events, selectable=False):
         if selectable:
             graph.add_sel_cpu_item(self.cpu, self)
         else:
             graph.draw_cpu_item(self.cpu, self.is_selected())
-            
+
 EVENT_LIST = {SuspendEvent : None, ResumeEvent : None, CompleteEvent : None,
               SwitchAwayEvent : None, SwitchToEvent : None, ReleaseEvent : None,
               DeadlineEvent : None, IsRunningDummy : None,
diff --git a/unit_trace/viz/util.py b/unit_trace/viz/util.py
index 3111f39..430063b 100644
--- a/unit_trace/viz/util.py
+++ b/unit_trace/viz/util.py
@@ -1,9 +1,78 @@
-#!/usr/bin/python
-
 """Miscellanious utility functions that don't fit anywhere."""
 
 def format_float(num, numplaces):
+    if num is None:
+        return '(None)'
+
     if abs(round(num, numplaces) - round(num, 0)) == 0.0:
         return '%.0f' % float(num)
     else:
-        return ('%.' + numplaces + 'f') % round(float(num), numplaces)
+        return ('%.' + str(numplaces) + 'f') % round(float(num), numplaces)
+
+class TimeUnit(object):
+    """Class that represents a certain time unit."""
+    def nsec_to_native(self, time):
+        raise NotImplementedError
+
+    def native_to_nsec(self, time):
+        raise NotImplementedError
+
+class NanoSec(TimeUnit):
+    def __str__(self):
+        return 'ns'
+
+    def nsec_to_native(self, time):
+        return time
+
+    def native_to_nsec(self, time):
+        return time
+
+class MicroSec(TimeUnit):
+    def __str__(self):
+        return 'us'
+
+    def nsec_to_native(self, time):
+        if time is None: return time
+        return time / 1000.0
+
+    def native_to_nsec(self, time):
+        if time is None: return time
+        return time * 1000.0
+
+class MilliSec(TimeUnit):
+    def __str__(self):
+        return 'ms'
+
+    def nsec_to_native(self, time):
+        if time is None: return time
+        return time / 1000000.0
+
+    def native_to_nsec(self, time):
+        if time is None: return time
+        return time * 1000000.0
+
+class Sec(TimeUnit):
+    def __str__(self):
+        return 's'
+
+    def nsec_to_native(self, time):
+        if time is None: return time
+        return time / 1000000000.0
+
+    def native_to_nsec(self, time):
+        if time is None: return time
+        return time * 1000000000.0
+
+def parse_unit(expr):
+    expr = expr.strip().lower()
+
+    if expr == 'ns' or expr == 'nsec' or expr == 'nsecs' or expr == 'nanosec' or expr == 'nanosecs':
+        return NanoSec()
+    elif expr == 'us' or expr == 'usec' or expr == 'usecs' or expr == 'microsec' or expr == 'microsecs':
+        return MicroSec()
+    elif expr == 'ms' or expr == 'msec' or expr == 'msecs' or expr == 'millisec' or expr == 'millisecs':
+        return MilliSec()
+    elif expr == 's' or expr == 'sec' or expr == 'secs' or expr == 'second' or expr == 'seconds':
+        return Sec()
+    else:
+        raise ValueError
diff --git a/unit_trace/viz/viewer.py b/unit_trace/viz/viewer.py
index 4f7a511..bb1385c 100644
--- a/unit_trace/viz/viewer.py
+++ b/unit_trace/viz/viewer.py
@@ -30,7 +30,7 @@ class GraphContextMenu(gtk.Menu):
         else:
             for layer in selected:
                 for event in selected[layer]:
-                    string = str(event)
+                    string = event.str_short(info_win.get_unit())
                     if len(string) > GraphContextMenu.MAX_STR_LEN - 3:
                         string = string[:GraphContextMenu.MAX_STR_LEN - 3] + '...'
                     item = gtk.MenuItem(string)
@@ -68,19 +68,23 @@ class GraphArea(gtk.DrawingArea):
         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)
+                        gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.EXPOSURE_MASK | gtk.gdk.LEAVE_NOTIFY_MASK)
 
         self.band_rect = None
         self.ctrl_clicked = False
+        self.cursor_pos = None
         self.last_selected = {}
         self.dirtied_regions = []
 
+        self.get_graph().update_view(self.cur_x, self.cur_y, self.width, self.height, self.scale)
+
         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)
+        self.connect('leave-notify-event', self.leave_notify)
 
     def output_to_file(self, filename, ftype):
         """Outputs the entire graph to a file."""
@@ -92,17 +96,17 @@ class GraphArea(gtk.DrawingArea):
             surface = SVGSurface()
         else:
             raise ValueError
-            
+
         surface.renew(graph.get_width(), graph.get_height())
         graph.set_tmp_surface(surface)
         graph.render_all(self.renderer.get_schedule())
         surface.write_out(filename)
         graph.revert_surface()
-        
+
     def expose(self, widget, expose_event, data=None):
         ctx = widget.window.cairo_create()
-        graph = self.renderer.get_graph()
-        graph.update_view(self.cur_x, self.cur_y, self.width, self.height, self.scale, ctx)
+        graph = self.get_graph()
+        graph.load_ctx(ctx)
 
         # If X caused the expose event, we need to update the entire area, not just the
         # changes we might have made. An expose event caused by X needs to take priority
@@ -113,11 +117,13 @@ class GraphArea(gtk.DrawingArea):
             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)
+        virt_dirtied_regions = graph.real_to_virt_list(self.dirtied_regions)
+        graph.render_surface(self.renderer.get_schedule(), virt_dirtied_regions)
 
         # render dragging band rectangle, if there is one
         if self.band_rect is not None:
-            x, y, width, height = self.band_rect
+            x, y, width, height = graph.virt_to_real(self.band_rect[0], self.band_rect[1],
+                                                     self.band_rect[2], self.band_rect[3])
             thickness = GraphFormat.BAND_THICKNESS
             color = GraphFormat.BAND_COLOR
 
@@ -136,21 +142,23 @@ class GraphArea(gtk.DrawingArea):
 
     def get_schedule(self):
         return self.renderer.get_schedule()
-    
+
     def zoom_in(self):
         scale = self.scale + GraphArea.ZOOM_INCR
         if scale > GraphArea.MAX_ZOOM_IN:
             scale = GraphArea.MAX_ZOOM_IN
         self.set_scale(scale)
         self.config_scrollbars(self.cur_x, self.cur_y, self.scale)
-        
+        self._pos_update()
+
     def zoom_out(self):
         scale = self.scale - GraphArea.ZOOM_INCR
         if scale < GraphArea.MIN_ZOOM_OUT:
             scale = GraphArea.MIN_ZOOM_OUT
         self.set_scale(scale)
         self.config_scrollbars(self.cur_x, self.cur_y, self.scale)
-        
+        self._pos_update()
+
     def set_scale(self, scale):
         if scale == self.scale:
             return
@@ -165,7 +173,7 @@ class GraphArea(gtk.DrawingArea):
         value = max(value, self.horizontal.get_lower())
         value = min(value, self.horizontal.get_upper() - self.horizontal.get_page_size())
         self.horizontal.set_value(value)
-    
+
     def set_vvalue(self, value):
         if self.vertical is None:
             return
@@ -173,7 +181,7 @@ class GraphArea(gtk.DrawingArea):
         value = max(value, self.vertical.get_lower())
         value = min(value, self.vertical.get_upper() - self.vertical.get_page_size())
         self.vertical.set_value(value)
-            
+
     def set_scroll_adjustments(self, widget, horizontal, vertical, data=None):
         graph = self.renderer.get_graph()
         width = graph.get_width()
@@ -192,20 +200,27 @@ class GraphArea(gtk.DrawingArea):
         self.cur_x = min(adjustment.value, self.renderer.get_graph().get_width())
         self.cur_x = max(adjustment.value, 0.0)
 
-        self.renderer.get_graph().render_surface(self.renderer.get_schedule(), [(0, 0, self.width, self.height)], True)
+        self.get_graph().render_surface(self.renderer.get_schedule(),
+            [self.get_graph().real_to_virt(0, 0, self.width, self.height)], True)
         self._dirty(0, 0, self.width, self.height)
 
+        self._pos_update()
+
     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.renderer.get_graph().render_surface(self.renderer.get_schedule(), [(0, 0, self.width, self.height)], True)
+        self.get_graph().render_surface(self.renderer.get_schedule(),
+            [self.get_graph().real_to_virt(0, 0, self.width, self.height)], True)
         self._dirty(0, 0, self.width, self.height)
 
+        self._pos_update()
+
     def size_allocate(self, widget, allocation):
         self.width = allocation.width
         self.height = allocation.height
         self.config_scrollbars(self.cur_x, self.cur_y, self.scale)
+        self._pos_update()
 
     def config_scrollbars(self, hvalue, vvalue, scale):
         graph = self.renderer.get_graph()
@@ -224,11 +239,11 @@ class GraphArea(gtk.DrawingArea):
                                 graph.get_attrs().y_item_size * GraphArea.VERT_PAGE_SCROLL_FACTOR / scale,
                                 self.height / scale)
             self.set_vvalue(vvalue)
-    
+
     def refresh_all(self):
         """Refreshes the entire visible screen."""
         self._dirty(0, 0, self.width, self.height)
-                
+
     def refresh_events(self, sender, new, old, replace):
         """Even if the selected areas change on one graph, they change
         everywhere, and different events might be in different regions on
@@ -240,7 +255,7 @@ class GraphArea(gtk.DrawingArea):
         refreshes the drawing of the graph that requested the change."""
         if self is not sender:
             self.renderer.get_graph().render_events(new, True)
-        
+
         self._tag_events(new)
 
         if self is sender:
@@ -252,7 +267,7 @@ class GraphArea(gtk.DrawingArea):
             else:
                 self.renderer.get_schedule().remove_selected(old)
                 self.renderer.get_schedule().add_selected(new)
-                
+
             self.emit('update-sel-changes', self.renderer.get_schedule().get_selected())
 
     def _find_max_layer(self, regions):
@@ -267,11 +282,9 @@ class GraphArea(gtk.DrawingArea):
         for layer in events:
             for event in events[layer]:
                 if not events[layer][event][self].is_dummy():
-                    x, y, width, height = events[layer][event][self].get_dimensions()
-                    self._dirty_inflate((x - self.cur_x) * self.scale,
-                                (y - self.cur_y) * self.scale,
-                                width * self.scale,
-                                height * self.scale,
+                    dim = events[layer][event][self].get_dimensions()
+                    x, y, width, height = self.get_graph().virt_to_real(dim[0], dim[1], dim[2], dim[3])
+                    self._dirty_inflate(x, y, width, height,
                                 GraphFormat.BORDER_THICKNESS * self.scale)
 
     def _tag_events(self, selected):
@@ -303,15 +316,27 @@ class GraphArea(gtk.DrawingArea):
         if event not in coll[event.get_layer()]:
             coll[event.get_layer()][event] = {}
 
+    def leave_notify(self, widget, leave_event):
+        self.cursor_pos = None
+        self.emit('update-event-description', None)
+
     def motion_notify(self, widget, motion_event, data=None):
-        msg = None
+        self.cursor_pos = (motion_event.x, motion_event.y)
+        self._pos_update()
+
+    def _pos_update(self):
+        self.get_graph().update_view(self.cur_x, self.cur_y, self.width, self.height, self.scale)
+
+        if self.cursor_pos is None:
+            return
 
         graph = self.renderer.get_graph()
 
-        graph.render_surface(self.renderer.get_schedule(), [(motion_event.x, motion_event.y,
-                             0, 0)], True)
+        graph.render_surface(self.renderer.get_schedule(),
+                    [graph.real_to_virt(self.cursor_pos[0], self.cursor_pos[1], 0, 0)], True)
 
-        just_selected = graph.get_intersecting_regions(motion_event.x, motion_event.y, 0, 0)
+        cur_x_v, cur_y_v, w, h = graph.real_to_virt(self.cursor_pos[0], self.cursor_pos[1], 0, 0)
+        just_selected = graph.get_intersecting_regions(cur_x_v, cur_y_v, 0, 0)
         was_selected = self.renderer.get_schedule().get_selected()
         if not just_selected:
             msg = ''
@@ -323,10 +348,11 @@ class GraphArea(gtk.DrawingArea):
                     the_event = event
                     break
 
-            msg = str(the_event)
+            msg = the_event.str_short(graph.get_attrs().unit)
 
-        self.emit('update-event-description', the_event, msg)
+        self.emit('update-event-description', the_event)
 
+        virt_x, virt_y, w, h = graph.real_to_virt(self.cursor_pos[0], self.cursor_pos[1], 0, 0)
         if self.band_rect is not None:
             remove_selected = {}
             add_selected = {}
@@ -334,14 +360,12 @@ class GraphArea(gtk.DrawingArea):
             # 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]
+            width = virt_x - self.band_rect[0]
+            height = virt_y - self.band_rect[1]
             old_x, old_y, old_width, old_height = self.band_rect
 
-            x_p, y_p, width_p, height_p = self._positivify(x, y, width, height)
-            old_x_p, old_y_p, old_width_p, old_height_p = self._positivify(old_x, old_y, old_width, old_height)
-            x_p, y_p, width_p, height_p = int(x_p), int(y_p), int(width_p), int(height_p)
-            old_x_p, old_y_p, old_width_p, old_height_p = int(old_x_p), int(old_y_p), int(old_width_p), int(old_height_p)
+            x_p, y_p, width_p, height_p = self._positivify_int(x, y, width, height)
+            old_x_p, old_y_p, old_width_p, old_height_p = self._positivify_int(old_x, old_y, old_width, old_height)
 
             new_reg = gtk.gdk.region_rectangle(gtk.gdk.Rectangle(x_p, y_p, width_p, height_p))
             old_reg = gtk.gdk.region_rectangle(gtk.gdk.Rectangle(old_x_p, old_y_p, old_width_p, old_height_p))
@@ -354,7 +378,7 @@ class GraphArea(gtk.DrawingArea):
             dirty_list = []
             for rect in remove_reg.get_rectangles():
                 dirty_list.append((rect.x, rect.y, rect.width, rect.height))
-            graph.render_surface(self.renderer.get_schedule(), dirty_list, True)
+            graph.render_surface(self.renderer.get_schedule(), graph.real_to_virt_list(dirty_list), True)
             for rect in dirty_list:
                 rx, ry, rwidth, rheight = rect
                 i_regs = graph.get_intersecting_regions(rx, ry, rwidth, rheight)
@@ -370,6 +394,7 @@ class GraphArea(gtk.DrawingArea):
             for rect in add_reg.get_rectangles():
                 dirty_list.append((rect.x, rect.y, rect.width, rect.height))
             graph.render_surface(self.renderer.get_schedule(), dirty_list, True)
+
             for rect in dirty_list:
                 rx, ry, rwidth, rheight = rect
                 i_regs = graph.get_intersecting_regions(rx, ry, rwidth, rheight)
@@ -380,8 +405,10 @@ class GraphArea(gtk.DrawingArea):
             self.band_rect = x, y, width, height
             self.emit('request-refresh-events', self, add_selected, remove_selected, False)
 
-            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)
+            x_r, y_r, width_r, height_r = graph.virt_to_real(x, y, width, height)
+            old_x_r, old_y_r, old_width_r, old_height_r = graph.virt_to_real(old_x, old_y, old_width, old_height)
+            self._dirty_rect_border(old_x_r, old_y_r, old_width_r, old_height_r, GraphFormat.BAND_THICKNESS * self.scale)
+            self._dirty_rect_border(x_r, y_r, width_r, height_r, GraphFormat.BAND_THICKNESS * self.scale)
 
     def button_press(self, widget, button_event, data=None):
         graph = self.renderer.get_graph()
@@ -391,10 +418,11 @@ class GraphArea(gtk.DrawingArea):
         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_intersecting_regions(button_event.x, button_event.y, 0, 0)
-            
+                                 [graph.real_to_virt(button_event.x, button_event.y, 0, 0)], True)
+
+            b_x_r, b_y_r, w, h = graph.real_to_virt(button_event.x, button_event.y, 0, 0)
+            just_selected = graph.get_intersecting_regions(b_x_r, b_y_r, 0, 0)
+
             max_layer = self._find_max_layer(just_selected)
 
             was_selected = self.renderer.get_schedule().get_selected()
@@ -418,7 +446,7 @@ class GraphArea(gtk.DrawingArea):
                                 and event in was_selected[max_layer]):
                             self._select_event(new_now_selected, event)
                         break # only pick one event when just clicking
-                
+
                 self.emit('request-refresh-events', self, new_now_selected, was_selected, True)
             else:
                 remove_selected = {}
@@ -435,7 +463,7 @@ class GraphArea(gtk.DrawingArea):
                 self.emit('request-refresh-events', self, add_selected, remove_selected, False)
 
             if self.band_rect is None:
-                self.band_rect = (button_event.x, button_event.y, 0, 0)
+                self.band_rect = (b_x_r, b_y_r, 0, 0)
 
         elif button_event.button == 3:
             self._release_band()
@@ -456,7 +484,8 @@ class GraphArea(gtk.DrawingArea):
     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)
+            x_r, y_r, width_r, height_r = self.get_graph().virt_to_real(x, y, width, height)
+            self._dirty_rect_border(x_r, y_r, width_r, height_r, GraphFormat.BAND_THICKNESS * self.scale)
             self.band_rect = None
 
     def _dirty(self, x, y, width, height):
@@ -498,6 +527,10 @@ class GraphArea(gtk.DrawingArea):
 
         return x, y, width, height
 
+    def _positivify_int(self, x, y, width, height):
+        p = self._positivify(x, y, width, height)
+        return (int(p[0]), int(p[1]), int(p[2]), int(p[3]))
+
 class GraphWindow(gtk.ScrolledWindow):
     def __init__(self, renderer):
         super(GraphWindow, self).__init__(None, None)
@@ -596,7 +629,7 @@ class MainWindow(gtk.Window):
 
     def __init__(self):
         super(MainWindow, self).__init__(gtk.WINDOW_TOPLEVEL)
-        
+
         self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
 
         self.connect('delete_event', self.delete_event)
@@ -608,11 +641,11 @@ class MainWindow(gtk.Window):
 
         agr = gtk.AccelGroup()
         self.add_accel_group(agr)
-        
+
         # list of file items that are clickable if and only if at
         # least one graph is viewable
         self.sensitive_menu_items = []
-        
+
         save_item = gtk.ImageMenuItem('_Save Graph to File')
         img = gtk.Image()
         img.set_from_stock(gtk.STOCK_SAVE_AS, gtk.ICON_SIZE_MENU)
@@ -623,7 +656,7 @@ class MainWindow(gtk.Window):
         save_item.connect('activate', self.save_item_activate)
         save_item.set_sensitive(False)
         self.sensitive_menu_items.append(save_item)
-        
+
         quit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
         key, mod = gtk.accelerator_parse('<Ctrl>Q')
         quit_item.add_accelerator('activate', agr, key, mod,
@@ -636,8 +669,8 @@ class MainWindow(gtk.Window):
         file_item = gtk.MenuItem('_File', True)
         file_item.set_submenu(file_menu)
 
-        move_item = gtk.ImageMenuItem('_Move to Time')
-        key, mod = gtk.accelerator_parse('<Ctrl>M')
+        move_item = gtk.ImageMenuItem('_Jump to Time')
+        key, mod = gtk.accelerator_parse('<Ctrl>J')
         img = gtk.Image()
         img.set_from_stock(gtk.STOCK_JUMP_TO, gtk.ICON_SIZE_MENU)
         move_item.set_image(img)
@@ -645,7 +678,7 @@ class MainWindow(gtk.Window):
             gtk.ACCEL_VISIBLE)
         move_item.set_sensitive(False)
         self.sensitive_menu_items.append(move_item)
-        
+
         move_item.connect('activate', self.move_to_time_activate)
 
         self.colors_item = gtk.ImageMenuItem('Co_lors')
@@ -656,14 +689,14 @@ class MainWindow(gtk.Window):
         self.colors_item.add_accelerator('activate', agr, key, mod,
             gtk.ACCEL_VISIBLE)
         self.colors_item.set_sensitive(False)
-        
+
         self.colors_item.connect('activate', self.colors_activate)
-        
+
         edit_menu.append(self.colors_item)
-        
+
         edit_item = gtk.MenuItem('_Edit', True)
         edit_item.set_submenu(edit_menu)
-        
+
         zoom_in_item = gtk.ImageMenuItem(gtk.STOCK_ZOOM_IN, agr)
         key, mod = gtk.accelerator_parse('<Ctrl>plus')
         zoom_in_item.add_accelerator('activate', agr, key, mod,
@@ -701,20 +734,23 @@ class MainWindow(gtk.Window):
         self.notebook.last_page = -1
         self.notebook.connect('switch-page', self.switch_page)
 
-        self.desc_label = gtk.Label('')
-        self.desc_label.set_alignment(0.0, 0.0)
+        self.event_label = gtk.Label('')
+        self.job_run_label = gtk.Label('')
+        self.job_rd_label = gtk.Label('')
 
         self.vbox.pack_start(menu_bar, False, False, 0)
         self.vbox.pack_start(self.notebook, True, True, 0)
-        self.vbox.pack_start(self.desc_label, False, False, 0)
-
+        self.vbox.pack_start(self.event_label, False, False, 0)
+        self.vbox.pack_start(self.job_run_label, False, False, 0)
+        self.vbox.pack_start(self.job_rd_label, False, False, 0)
         self.add(self.vbox)
 
         self.info_win = InfoWindow()
+        self.text_input_dialog = TextInputDialog('Move to Time', 'how is babby formed?', self)
         self.color_dialog = gtk.ColorSelectionDialog('Choose Item Color')
-        
+
         self.cur_item_no = None
-        
+
         self.set_size_request(MainWindow.WINDOW_WIDTH_REQ, MainWindow.WINDOW_HEIGHT_REQ)
 
         self.set_title('Unit-Trace Visualizer')
@@ -736,7 +772,7 @@ class MainWindow(gtk.Window):
             self.connect_widgets(gwindow)
             gwindow.show()
             self.notebook.append_page(gwindow, gtk.Label(title))
-        
+
         if self.notebook.get_n_pages() > 0:
             self.notebook.get_nth_page(0).grab_focus()
 
@@ -750,14 +786,14 @@ class MainWindow(gtk.Window):
     def update_sel_changes(self, widget, selected):
         """Modify the GUI appropriately to reflect a change in selection."""
         self.selected = selected
-        
+
         self.cur_item_no = self.notebook.get_nth_page(self.notebook.last_page).get_graph_area() \
                 .get_graph().all_one_item_selected(selected)
         if self.cur_item_no is not None:
             self.colors_item.set_sensitive(True)
         else:
-            self.colors_item.set_sensitive(False)    
-        
+            self.colors_item.set_sensitive(False)
+
     def switch_page(self, widget, page, page_num):
         if self.notebook.get_nth_page(self.notebook.last_page) is not None:
             old_value = self.notebook.get_nth_page(self.notebook.last_page).get_hadjustment().get_value()
@@ -765,11 +801,28 @@ 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)
+            unit = self.notebook.get_nth_page(page_num).get_graph_area().get_graph().get_attrs().unit
+            self.info_win.set_unit(unit)
 
         self.notebook.last_page = page_num
 
-    def update_event_description(self, widget, event, msg):
-        self.desc_label.set_text(msg)
+    def update_event_description(self, widget, event):
+        if event is None:
+            self.event_label.set_text('')
+            self.job_run_label.set_text('')
+            self.job_rd_label.set_text('')
+            return
+
+        unit = self.notebook.get_nth_page(self.notebook.last_page).get_graph_area() \
+               .get_graph().get_attrs().unit
+        self.event_label.set_text(event.str_short(unit))
+        job = event.get_job()
+        if job is None:
+            self.job_run_label.set_text('')
+            self.job_rd_label.set_text('')
+        else:
+            self.job_run_label.set_text(job.str_run_short(unit))
+            self.job_rd_label.set_text(job.str_rd_short(unit))
 
     def request_context_menu(self, widget, gdk_event, selected):
         button = 0
@@ -789,23 +842,34 @@ class MainWindow(gtk.Window):
             if self.notebook.get_nth_page(i).get_graph_area() is sender:
                 self.notebook.get_nth_page(i).get_graph_area().refresh_events(sender, old, new, replace)
                 break
-                
+
     def move_to_time_activate(self, widget):
-        dialog = TextInputDialog('Move to Time', 'What time to move to?', self)
+        unit = self.notebook.get_nth_page(self.notebook.last_page).get_graph_area() \
+                           .get_graph().get_attrs().unit
+
+        self.text_input_dialog.set_prompt('What time to move to (default ' + str(unit) + ') ?')
 
         err = True
         while err:
-            ret = dialog.run()
+            ret = self.text_input_dialog.run()
 
             if ret == gtk.RESPONSE_ACCEPT:
                 err, time = None, None
                 try:
-                    time = float(dialog.get_input())
-                    start, end = self.notebook.get_nth_page(0).get_graph_area().get_schedule().get_time_bounds()
+                    input_tokens = self.text_input_dialog.get_input().split()
+                    if len(input_tokens) > 2:
+                        raise ValueError
+
+                    if len(input_tokens) > 1:
+                        unit = util.parse_unit(input_tokens[1])
+
+                    time = unit.native_to_nsec(float(input_tokens[0]))
+                    start, end = self.notebook.get_nth_page(self.notebook.last_page).get_graph_area() \
+                                 .get_schedule().get_time_bounds()
                     if time < start or time > end:
                         err = 'Time out of range!'
                 except ValueError:
-                    err = 'Must input a number!'
+                    err = 'Must input a number (with an optional unit)!'
 
                 if not err:
                     for i in xrange(0, self.notebook.get_n_pages()):
@@ -820,12 +884,12 @@ class MainWindow(gtk.Window):
                                                          err)
                     err_dialog.set_title('Input Error')
                     err_dialog.run()
-                    err_dialog.destroy()
+                    err_dialog.hide()
 
             else:
                 break
 
-        dialog.destroy()
+        self.text_input_dialog.hide()
 
     def zoom_in_item_activate(self, widget):
         for i in range(0, self.notebook.get_n_pages()):
@@ -838,13 +902,13 @@ class MainWindow(gtk.Window):
     def colors_activate(self, widget):
         garea = self.notebook.get_nth_page(self.notebook.last_page).get_graph_area()
         graph = garea.get_renderer().get_graph()
-        
-        
+
+
         pattern = graph.get_bar_pattern(self.cur_item_no)
-        
+
         if len(pattern.get_color_list()) > 1:
             print 'striped patterns not yet supported'
-        
+
         r, g, b = pattern.get_color_list()[0]
         colorsel = self.color_dialog.get_color_selection()
         cur_color = gtk.gdk.Color(int(r * 65535), int(g * 65535), int(b * 65535))
@@ -857,34 +921,34 @@ class MainWindow(gtk.Window):
             r, g, b = color.red / 65535.0, color.green / 65535.0, color.blue / 65535.0
             graph.set_bar_pattern(self.cur_item_no, Pattern([(r, g, b)]))
             garea.refresh_all()
-            
+
         self.color_dialog.hide()
-        
+
     def save_item_activate(self, widget):
         ACCEPTED_TYPES = ('png', 'svg')
-        
+
         dialog = gtk.FileChooserDialog('Save to Graphics File', self,
                                         gtk.FILE_CHOOSER_ACTION_SAVE,
                                         (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
                                         gtk.STOCK_SAVE, gtk.RESPONSE_ACCEPT))
-        
+
         png_filter = gtk.FileFilter()
         png_filter.add_mime_type('image/png')
         png_filter.set_name('PNG image (*.png)')
         dialog.add_filter(png_filter)
-        
+
         svg_filter = gtk.FileFilter()
         svg_filter.add_mime_type('image/svg+xml')
         svg_filter.set_name('SVG vector image (*.svg)')
         dialog.add_filter(svg_filter)
-        
+
         filename = None
         ftype = None
         while True:
             if dialog.run() == gtk.RESPONSE_ACCEPT:
                 filename = dialog.get_filename()
                 # parse filename for extension
-            
+
                 parts = filename.split('.')
                 ftype = None
                 if len(parts) == 1:
@@ -910,7 +974,7 @@ class MainWindow(gtk.Window):
                 filename = None
                 ftype = None
                 break
-                
+
         if filename is not None:
             cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)
             dialog.get_window().set_cursor(cursor)
@@ -919,9 +983,9 @@ class MainWindow(gtk.Window):
                 dialog.get_window().set_cursor(None)
                 dialog.destroy()
             gobject.idle_add(idle_callback, dialog) # needed to get the cursor to display
-        else:    
+        else:
             dialog.destroy()
-        
+
     def quit_item_activate(self, widget):
         self.destroy()
 
diff --git a/unit_trace/viz/windows.py b/unit_trace/viz/windows.py
index 4e5af5c..cd75398 100644
--- a/unit_trace/viz/windows.py
+++ b/unit_trace/viz/windows.py
@@ -8,20 +8,20 @@ class TextInputDialog(gtk.Dialog):
     WINDOW_WIDTH_REQ = 250
     WINDOW_HEIGHT_REQ = 100
 
-    def __init__(self, title, label, parent_window=None):
+    def __init__(self, title, prompt, parent_window=None):
         super(TextInputDialog, self).__init__(title, parent_window,
                             gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
                             (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
                             gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
-        label_widget = gtk.Label(label)
-        label_widget.set_alignment(0.0, 0.0)
+        self.label_widget = gtk.Label(prompt)
+        self.label_widget.set_alignment(0.0, 0.0)
         self.text_input = gtk.Entry()
-        label_widget.show()
+        self.label_widget.show()
         self.text_input.show()
 
         vbox = self.get_content_area()
 
-        vbox.pack_start(label_widget, False, False, 0)
+        vbox.pack_start(self.label_widget, False, False, 0)
         vbox.pack_start(self.text_input, False, False, 0)
         vbox.show()
 
@@ -29,6 +29,9 @@ class TextInputDialog(gtk.Dialog):
 
         self.set_size_request(TextInputDialog.WINDOW_WIDTH_REQ, TextInputDialog.WINDOW_HEIGHT_REQ)
 
+    def set_prompt(self, text):
+        self.label_widget.set_text(text)
+
     def get_input(self):
         return self.text_input.get_text()
 
@@ -57,9 +60,18 @@ class InfoWindow(gtk.Window):
 
         self.add(self.vbox)
 
+        self.unit = None
+
         self.set_default_size(InfoWindow.WINDOW_WIDTH_REQ, InfoWindow.WINDOW_HEIGHT_REQ)
         self.set_title('Event Details')
 
     def set_event(self, event):
-        self.text_view.get_buffer().set_text(event.str_long())
+        self.text_view.get_buffer().set_text(event.str_long(self.unit))
         self.frm.set_label('Details for ' + event.get_name())
+
+    def set_unit(self, unit):
+        self.unit = unit
+
+    def get_unit(self):
+        return self.unit
+