Fixed some graphical glitches, along with streamlining the access to the visualizer.

1 files changed, 109 insertions, 73 deletions

diff --git a/unit_trace/viz/viewer.py b/unit_trace/viz/viewer.py
index 120c7e7..236a467 100644
--- a/unit_trace/viz/viewer.py
+++ b/unit_trace/viz/viewer.py
@@ -9,6 +9,7 @@ from renderer import *
 import pygtk
 import gtk
 import gobject
+import copy
 
 class GraphContextMenu(gtk.Menu):
     MAX_STR_LEN = 80
@@ -30,8 +31,7 @@ class GraphArea(gtk.DrawingArea):
     VERT_PAGE_SCROLL_FACTOR = 3.0
     VERT_STEP_SCROLL_FACTOR = 0.5
     
-    SELECT_THICKNESS = 1.5
-    SELECT_COLOR = (0.85, 0.0, 0.0)
+    REFRESH_INFLATION_FACTOR = 20.0
     
     def __init__(self, renderer):
         super(GraphArea, self).__init__()
@@ -46,11 +46,11 @@ 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.BUTTON_RELEASE_MASK | gtk.gdk.EXPOSURE_MASK)
         
-        self.left_button_start_coor = None
-        self.select_rect = None
+        self.band_rect = None
         self.ctrl_clicked = False
+        self.dirtied_regions = []
         
         self.connect('expose-event', self.expose)
         self.connect('size-allocate', self.size_allocate)
@@ -59,23 +59,34 @@ class GraphArea(gtk.DrawingArea):
         self.connect('button-release-event', self.button_release)
         self.connect('motion-notify-event', self.motion_notify)
         
-    def expose(self, widget, event, data=None):
+    def expose(self, widget, expose_event, data=None):
         ctx = widget.window.cairo_create()
         graph = self.renderer.get_graph()
         graph.update_view(self.cur_x, self.cur_y, self.width, self.height, ctx)
-        graph.render_surface(self.renderer.get_schedule(), 0, 0, self.width, self.height)
         
-        # render dragging rectangle, if there is one
-        if self.select_rect is not None:
-            x, y, width, height = self.select_rect
-            thickness = GraphArea.SELECT_THICKNESS
-            color = GraphArea.SELECT_COLOR
+        # We ourselves didn't update dirtied_regions, so this means that X or the
+        # window manager must have caused the expose event. So just update the
+        # expose_event's bounding area.
+        if not self.dirtied_regions or expose_event.send_event:
+            print 'forced expose'
+            self.dirtied_regions = [(expose_event.area.x, expose_event.area.y,
+                                     expose_event.area.width, expose_event.area.height)]
+                                  
+        graph.render_surface(self.renderer.get_schedule(), self.dirtied_regions)
+        
+        # render dragging band rectangle, if there is one
+        if self.band_rect is not None:
+            x, y, width, height = self.band_rect
+            thickness = GraphFormat.BAND_THICKNESS
+            color = GraphFormat.BAND_COLOR
             
             ctx.rectangle(x, y, width, height)            
             ctx.set_line_width(thickness)
             ctx.set_source_rgb(color[0], color[1], color[2])
             ctx.stroke()
-    
+        
+        self.dirtied_regions = []
+        
     def get_renderer(self):
         return self.renderer
         
@@ -100,15 +111,13 @@ class GraphArea(gtk.DrawingArea):
         self.cur_x = min(adjustment.value, self.renderer.get_graph().get_width())
         self.cur_x = max(adjustment.value, 0.0)
         
-        rect = gtk.gdk.Rectangle(0, 0, self.width, self.height)
-        self.window.invalidate_rect(rect, True)
+        self._dirty(0, 0, self.width, self.height)
     
     def vertical_value_changed(self, adjustment):
         self.cur_y = min(adjustment.value, self.renderer.get_graph().get_height())
         self.cur_y = max(adjustment.value, 0.0)
         
-        rect = gtk.gdk.Rectangle(0, 0, self.width, self.height)
-        self.window.invalidate_rect(rect, True)
+        self._dirty(0, 0, self.width, self.height)
             
     def size_allocate(self, widget, allocation):
         self.width = allocation.width
@@ -133,13 +142,25 @@ class GraphArea(gtk.DrawingArea):
             if event.get_layer() > max_layer:
                 max_layer = event.get_layer()
         return max_layer
-        
+    
+    def _update_event_changes(self, list1, list2):
+        # if an event changed selected status, update the bounding area
+        for event in list1:
+            if event not in list2:
+                x, y, width, height = list1[event].get_dimensions()
+                self._dirty_inflate(x - self.cur_x, y - self.cur_y, width, height, GraphFormat.BORDER_THICKNESS)
+        for event in list2:
+            if event not in list1:
+                x, y, width, height = list2[event].get_dimensions()
+                self._dirty_inflate(x - self.cur_x, y - self.cur_y, width, height, GraphFormat.BORDER_THICKNESS)
+                        
     def motion_notify(self, widget, motion_event, data=None):
         msg = None
         
         graph = self.renderer.get_graph()
         
-        graph.render_surface(self.renderer.get_schedule(), motion_event.x, motion_event.y, 0, 0, True)
+        graph.render_surface(self.renderer.get_schedule(), [(motion_event.x, motion_event.y,
+                             0, 0)], True)
         just_selected = graph.get_selected_regions(motion_event.x, motion_event.y, 0, 0)
         if not just_selected:
             msg = ''
@@ -156,25 +177,31 @@ class GraphArea(gtk.DrawingArea):
         
         self.emit('update-event-description', the_event, msg)
         
-        if self.left_button_start_coor is not None:
+        if self.band_rect is not None:
             selected = {}
+            was_selected = self.renderer.get_schedule().get_selected()
             if self.ctrl_clicked:
-                selected = dict(self.last_selected)
+                selected = copy.copy(was_selected)
                 
             # dragging a rectangle
-            x = min(self.left_button_start_coor[0], motion_event.x)
-            y = min(self.left_button_start_coor[1], motion_event.y)
-            width = abs(self.left_button_start_coor[0] - motion_event.x)
-            height = abs(self.left_button_start_coor[1] - motion_event.y)
+            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]
             
-            graph.render_surface(self.renderer.get_schedule(), x, y, width, height, True)
-            selected.update(graph.get_selected_regions(x, y, width, height))
+            x_p, y_p, width_p, height_p = self._positivify(x, y, width, height)
+            graph.render_surface(self.renderer.get_schedule(), [(x_p, y_p, width_p, height_p)], True)
+            selected.update(graph.get_selected_regions(x_p, y_p, width_p, height_p))
             self.renderer.get_schedule().set_selected(selected)
     
-            self.select_rect = (x, y, width, height)
+            old_x, old_y, old_width, old_height = self.band_rect
+            self.band_rect = (x, y, width, height)
             
-            self._dirty()
+            self._dirty_rect_border(old_x, old_y, old_width, old_height, GraphFormat.BAND_THICKNESS)
+            self._dirty_rect_border(x, y, width, height, GraphFormat.BAND_THICKNESS)
         
+            self._update_event_changes(was_selected, selected)
+            
     def button_press(self, widget, button_event, data=None):
         graph = self.renderer.get_graph()
         
@@ -183,15 +210,16 @@ 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)
+                                 [(button_event.x, button_event.y, 0, 0)], True)
             
             just_selected = graph.get_selected_regions(button_event.x, button_event.y, 0, 0)
             
             max_layer = self._find_max_layer(just_selected)
             
             new_now_selected = None
+            was_selected = self.renderer.get_schedule().get_selected()
             if self.ctrl_clicked:
-                new_now_selected = self.renderer.get_schedule().get_selected()
+                new_now_selected = copy.copy(was_selected)
             else:
                 new_now_selected = {}
                 
@@ -206,45 +234,75 @@ class GraphArea(gtk.DrawingArea):
                     if (len(now_selected) == 1 or self.ctrl_clicked) and event in now_selected:
                         val = not event.is_selected
                     if val:
-                        new_now_selected[event] = None
+                        new_now_selected[event] = graph.get_sel_region(event)
                     elif event in new_now_selected:
                         del new_now_selected[event]
                     break # only pick one event when just clicking
             
             self.renderer.get_schedule().set_selected(new_now_selected)
-            self.last_selected = dict(new_now_selected)
+            #self.last_selected = new_now_selected
             
-            self._dirty()
+            self._update_event_changes(new_now_selected, was_selected)
+            
+            if self.band_rect is None:
+                self.band_rect = (button_event.x, button_event.y, 0, 0)
+                    
         elif button_event.button == 3:
             self._release_band()
             self.emit('request-context-menu', button_event, self.renderer.get_schedule().get_selected())
                                     
     def button_release(self, widget, button_event, data=None):
         self.ctrl_clicked = False
-        self.last_selected = dict(self.renderer.get_schedule().get_selected())
+        #self.last_selected = copy.copy(self.renderer.get_schedule().get_selected())
         
         if button_event.button == 1:
             self._release_band()
     
     def _release_band(self):
-        old_select_rect = self.select_rect
-        self.left_button_start_coor = None
-        self.select_rect = None
-        if old_select_rect is not None:
-            self._dirty()
+        if self.band_rect is not None:
+            x, y, width, height = self.band_rect
+            self._dirty_rect_border(x, y, width, height, GraphFormat.BAND_THICKNESS)
+            self.band_rect = None
                             
-    def _dirty(self, x=None, y=None, width=None, height=None):
-        if x is None:
-            x = 0
-        if y is None:
-            y = 0
-        if width is None:
-            width = self.width
-        if height is None:
-            height = self.height
+    def _dirty(self, x, y, width, height):
+        x = max(int(math.floor(x)), 0)
+        y = max(int(math.floor(y)), 0)
+        width = min(int(math.ceil(width)), self.width)
+        height = min(int(math.ceil(height)), self.height)
+        
+        self.dirtied_regions.append((x, y, width, height))
+        
         rect = gtk.gdk.Rectangle(x, y, width, height)
         self.window.invalidate_rect(rect, True)
-                 
+    
+    def _dirty_inflate(self, x, y, width, height, thickness):
+        t = thickness * GraphArea.REFRESH_INFLATION_FACTOR
+        x -= t / 2.0
+        y -= t / 2.0
+        width += t
+        height += t
+        self._dirty(x, y, width, height)
+        
+    def _dirty_rect_border(self, x, y, width, height, thickness):
+        # support rectangles with negative width and height (i.e. -width = width, but going leftwards
+        # instead of rightwards)
+        x, y, width, height = self._positivify(x, y, width, height)
+        
+        self._dirty_inflate(x, y, width, 0, thickness)
+        self._dirty_inflate(x, y, 0, height, thickness)
+        self._dirty_inflate(x, y + height, width, 0, thickness)
+        self._dirty_inflate(x + width, y, 0, height, thickness)
+    
+    def _positivify(self, x, y, width, height):
+        if width < 0:
+            x += width
+            width = -width
+        if height < 0:
+            y += height
+            height = -height
+        
+        return x, y, width, height
+        
 class GraphWindow(gtk.ScrolledWindow):    
     def __init__(self, renderer):
         super(GraphWindow, self).__init__(None, None)
@@ -310,20 +368,13 @@ class MainWindow(gtk.Window):
     WINDOW_WIDTH_REQ = 500
     WINDOW_HEIGHT_REQ = 300
     
-    def __init__(self, request_renderer_change):
+    def __init__(self):
         super(MainWindow, self).__init__(gtk.WINDOW_TOPLEVEL)
         
         self.connect('delete_event', self.delete_event)
         self.connect('destroy', self.die)
-    
-        self.connect('request-renderer-change', request_renderer_change)
         
         self.file_menu = gtk.Menu()
-        self.open_item = gtk.MenuItem('_Open', True)
-        self.open_item.connect('activate', self.open_item_activate)
-        self.file_menu.append(self.open_item)
-        self.open_item.show()
-        
         self.quit_item = gtk.MenuItem('_Quit', True)
         self.quit_item.connect('activate', self.quit_item_activate)
         self.quit_item.show()
@@ -397,21 +448,6 @@ class MainWindow(gtk.Window):
         menu = GraphContextMenu(selected)
         menu.popup(None, None, None, button, time)
         
-    def open_item_activate(self, widget):
-        dialog = gtk.FileChooserDialog('Open File', self,
-                                   gtk.FILE_CHOOSER_ACTION_OPEN,
-                                   (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
-                                               gtk.STOCK_OPEN, gtk.RESPONSE_ACCEPT))
-        dialog.set_select_multiple(True)
-            
-        if dialog.run() == gtk.RESPONSE_ACCEPT:
-            filenames = dialog.get_filenames()
-            dialog.destroy()
-            self.emit('request-renderer-change', filenames, None)
-        else:
-            dialog.destroy()
-        
-        
     def quit_item_activate(self, widget):
         self.destroy()