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

1 files changed, 155 insertions, 91 deletions

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