Making sure everything committed

1 files changed, 309 insertions, 98 deletions

diff --git a/unit_trace/viz/viewer.py b/unit_trace/viz/viewer.py
index 909da76..9b8502a 100644
--- a/unit_trace/viz/viewer.py
+++ b/unit_trace/viz/viewer.py
@@ -17,21 +17,28 @@ class GraphContextMenu(gtk.Menu):
     def __init__(self, selected):
         super(GraphContextMenu, self).__init__()
         
-        for event in selected:
-            string = str(event)
-            if len(string) > GraphContextMenu.MAX_STR_LEN - 3:
-                string = string[:GraphContextMenu.MAX_STR_LEN - 3] + '...'
-            item = gtk.MenuItem(string)
+        if not selected:
+            item = gtk.MenuItem("(No events selected)")
+            item.set_sensitive(False)
             self.append(item)
             item.show()
-            
+        else:    
+            for layer in selected:
+                for event in selected[layer]:
+                    string = str(event)
+                    if len(string) > GraphContextMenu.MAX_STR_LEN - 3:
+                        string = string[:GraphContextMenu.MAX_STR_LEN - 3] + '...'
+                    item = gtk.MenuItem(string)
+                    self.append(item)
+                    item.show()
+        
 class GraphArea(gtk.DrawingArea):
     HORIZ_PAGE_SCROLL_FACTOR = 10.8
     HORIZ_STEP_SCROLL_FACTOR = 0.8
     VERT_PAGE_SCROLL_FACTOR = 3.0
     VERT_STEP_SCROLL_FACTOR = 0.5
     
-    REFRESH_INFLATION_FACTOR = 20.0
+    REFRESH_INFLATION_FACTOR = 4.0
     
     def __init__(self, renderer):
         super(GraphArea, self).__init__()
@@ -42,6 +49,7 @@ class GraphArea(gtk.DrawingArea):
         self.cur_y = 0
         self.width = 0
         self.height = 0
+        self.scale = 1.0
         
         self.set_set_scroll_adjustments_signal('set-scroll-adjustments')
         
@@ -50,6 +58,7 @@ class GraphArea(gtk.DrawingArea):
         
         self.band_rect = None
         self.ctrl_clicked = False
+        self.last_selected = {}
         self.dirtied_regions = []
         
         self.connect('expose-event', self.expose)
@@ -62,7 +71,7 @@ class GraphArea(gtk.DrawingArea):
     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.update_view(self.cur_x, self.cur_y, self.width, self.height, self.scale, ctx)
         
         # We ourselves didn't update dirtied_regions, so this means that X or the
         # window manager must have caused the expose event. So just update the
@@ -91,7 +100,30 @@ class GraphArea(gtk.DrawingArea):
         
     def get_graph(self):
         return self.renderer.get_graph()
+    
+    MIN_ZOOM_OUT = 0.25
+    MAX_ZOOM_IN = 4.0
+    ZOOM_INCR = 0.25
+    
+    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)
+        
+    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)
+        
+    def set_scale(self, scale):
+        if scale == self.scale:
+            return
             
+        self.scale = scale
+        self._dirty(0, 0, self.width, self.height)
+        
     def set_scroll_adjustments(self, widget, horizontal, vertical, data=None):
         graph = self.renderer.get_graph()
         width = graph.get_width()
@@ -110,12 +142,14 @@ 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._dirty(0, 0, self.width, self.height)
     
     def vertical_value_changed(self, adjustment):
         self.cur_y = min(adjustment.value, self.renderer.get_graph().get_height())
         self.cur_y = max(adjustment.value, 0.0)
         
+        self.renderer.get_graph().render_surface(self.renderer.get_schedule(), [(0, 0, self.width, self.height)], True)
         self._dirty(0, 0, self.width, self.height)
             
     def size_allocate(self, widget, allocation):
@@ -129,12 +163,38 @@ class GraphArea(gtk.DrawingArea):
         height = graph.get_height()
         
         if self.horizontal is not None:
-            self.horizontal.set_all(hvalue, 0.0, width, graph.get_attrs().maj_sep * GraphArea.HORIZ_STEP_SCROLL_FACTOR,
+            self.horizontal.set_all(hvalue, 0.0, width + self.width,
+                                graph.get_attrs().maj_sep * GraphArea.HORIZ_STEP_SCROLL_FACTOR,
                                 graph.get_attrs().maj_sep * GraphArea.HORIZ_PAGE_SCROLL_FACTOR, self.width)
         if self.vertical is not None:
-            self.vertical.set_all(vvalue, 0.0, height, graph.get_attrs().y_item_size * GraphArea.VERT_STEP_SCROLL_FACTOR,
+            self.vertical.set_all(vvalue, 0.0, height + self.height,
+                                graph.get_attrs().y_item_size * GraphArea.VERT_STEP_SCROLL_FACTOR,
                                 graph.get_attrs().y_item_size * GraphArea.VERT_PAGE_SCROLL_FACTOR, self.height) 
     
+    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
+        different graphs. So when an event is selected on one graph its
+        region on a completely different graph needs to be updated. This
+        is why this method is here: given the graph that requested the
+        change, the old set of events selected, and the new set of events
+        selected, it updates the selected regions of this graph, and
+        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:
+            self._copy_tags(old)
+            self._dirty_events(new)
+            self._dirty_events(old)
+            if replace:
+                self.renderer.get_schedule().set_selected(new)
+            else:
+                self.renderer.get_schedule().remove_selected(old)
+                self.renderer.get_schedule().add_selected(new)
+            
     def _find_max_layer(self, regions):
         max_layer = Canvas.BOTTOM_LAYER
         for event in regions:
@@ -142,17 +202,46 @@ class GraphArea(gtk.DrawingArea):
                 max_layer = event.get_layer()
         return max_layer
     
-    def _update_event_changes(self, list1, list2):
+    def _dirty_events(self, events):
         # 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)
-                        
+        for layer in events:
+            for event in events[layer]:
+                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,
+                                GraphFormat.BORDER_THICKNESS * self.scale)
+    
+    def _tag_events(self, selected):
+        """Some of the events in the collection of selected events might be new.
+        In this case, these events are not yet associated with the region on
+        the graph that they belong to. This method fixes this.
+        """
+        graph = self.renderer.get_graph()
+        for layer in selected:
+            for event in selected[layer]:
+                # note that each graph has its own region associated
+                # with the event
+                selected[layer][event][self] = graph.get_sel_region(event)
+    
+    def _copy_tags(self, selected):
+        """When we want to specify a collection of selected events to perform
+        an operation on, we usually do not know ahead of time what regions (in
+        which graphs) the events are associated with. But we have this information
+        stored in the collection of all selected events. This method just copies
+        this information over to the selected variable."""
+        cur_selected = self.renderer.get_schedule().get_selected()
+        for layer in selected:
+            for event in selected[layer]:
+                selected[layer][event] = cur_selected[layer][event]
+        
+    def _select_event(self, coll, event):
+        if event.get_layer() not in coll:
+            coll[event.get_layer()] = {}
+        if event not in coll[event.get_layer()]:
+            coll[event.get_layer()][event] = {}
+            
     def motion_notify(self, widget, motion_event, data=None):
         msg = None
         
@@ -160,7 +249,9 @@ class GraphArea(gtk.DrawingArea):
         
         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)
+        was_selected = self.renderer.get_schedule().get_selected()
         if not just_selected:
             msg = ''
             the_event = None
@@ -177,30 +268,57 @@ class GraphArea(gtk.DrawingArea):
         self.emit('update-event-description', the_event, msg)
         
         if self.band_rect is not None:
-            selected = {}
-            was_selected = self.renderer.get_schedule().get_selected()
-            if self.ctrl_clicked:
-                selected = copy.copy(was_selected)
+            remove_selected = {}
+            add_selected = {}
                 
             # dragging a rectangle
             x = self.band_rect[0]
             y = self.band_rect[1]
             width = motion_event.x - self.band_rect[0]
             height = motion_event.y - self.band_rect[1]
+            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)
-            graph.render_surface(self.renderer.get_schedule(), [(x_p, y_p, width_p, height_p)], True)
-            selected.update(graph.get_selected_regions(x_p, y_p, width_p, height_p))
-            self.renderer.get_schedule().set_selected(selected)
-    
-            old_x, old_y, old_width, old_height = self.band_rect
-            self.band_rect = (x, y, width, height)
+            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)
+        
+            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))
+            
+            # To find the events that should be deselected and the new events that should be selected, compute
+            # the set differences between the old and new selection rectangles
+            
+            remove_reg = gtk.gdk.region_rectangle(gtk.gdk.Rectangle(old_x_p, old_y_p, old_width_p, old_height_p))
+            remove_reg.subtract(new_reg)
+            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)
+            for rect in dirty_list:
+                rx, ry, rwidth, rheight = rect
+                for event in graph.get_selected_regions(rx, ry, rwidth, rheight):
+                    if event.get_layer() in was_selected and event in was_selected[event.get_layer()]:
+                        self._select_event(remove_selected, event)
+            
+            add_reg = gtk.gdk.region_rectangle(gtk.gdk.Rectangle(x_p, y_p, width_p, height_p))
+            add_reg.subtract(old_reg)
+            dirty_list = [(x_p, y_p, width_p, 0), (x_p, y_p, 0, height_p),
+                          (x_p, y_p + height_p, width_p, 0), (x_p + width_p, y_p, 0, height_p)]
+            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
+                for event in graph.get_selected_regions(rx, ry, rwidth, rheight):
+                    self._select_event(add_selected, event)
+            
+            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)
-        
-            self._update_event_changes(was_selected, selected)
-            
+    
     def button_press(self, widget, button_event, data=None):
         graph = self.renderer.get_graph()
         
@@ -215,34 +333,43 @@ class GraphArea(gtk.DrawingArea):
             
             max_layer = self._find_max_layer(just_selected)
             
-            new_now_selected = None
             was_selected = self.renderer.get_schedule().get_selected()
-            if self.ctrl_clicked:
-                new_now_selected = copy.copy(was_selected)
-            else:
+            if not self.ctrl_clicked:
                 new_now_selected = {}
                 
-            # only select those events which were in the top layer (it's
-            # not intuitive to click something and then have something
-            # below it get selected). Also, clicking something that
-            # is selected deselects it, if it's the only thing selected
-            for event in just_selected:
-                if event.get_layer() == max_layer:
-                    val = True
-                    now_selected = self.renderer.get_schedule().get_selected()
-                    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] = 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 = new_now_selected
-            
-            self._update_event_changes(new_now_selected, was_selected)
+                more_than_one = 0
+                for layer in was_selected:
+                    for event in was_selected[layer]:
+                        more_than_one += 1
+                        if more_than_one > 1:
+                            break
+                            
+                # only select those events which were in the top layer (it's
+                # not intuitive to click something and then have something
+                # below it get selected). Also, clicking something that
+                # is selected deselects it, if it's the only thing selected
+                for event in just_selected:
+                    if event.get_layer() == max_layer:
+                        if not (more_than_one == 1 and event in was_selected):
+                            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 = {}
+                add_selected = {}
+                
+                for event in just_selected:
+                    layer = event.get_layer()
+                    if layer == max_layer:
+                        if layer in was_selected and event in was_selected[layer]:
+                            self._select_event(remove_selected, event)
+                        else:
+                            self._select_event(add_selected, event)
+                        break # again, only pick one event because we are just clicking
+                
+                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)
                     
@@ -252,11 +379,10 @@ class GraphArea(gtk.DrawingArea):
                                     
     def button_release(self, widget, button_event, data=None):
         self.ctrl_clicked = False
-        #self.last_selected = copy.copy(self.renderer.get_schedule().get_selected())
         
         if button_event.button == 1:
             self._release_band()
-    
+                    
     def _release_band(self):
         if self.band_rect is not None:
             x, y, width, height = self.band_rect
@@ -306,20 +432,45 @@ class GraphWindow(gtk.ScrolledWindow):
     def __init__(self, renderer):
         super(GraphWindow, self).__init__(None, None)
         
-        self.add_events(gtk.gdk.KEY_PRESS_MASK)
+        self.add_events(gtk.gdk.KEY_PRESS_MASK | gtk.gdk.SCROLL_MASK)
         
         self.ctr = 0
         self.connect('key-press-event', self.key_press)
+        self.connect('scroll-event', self.scroll)
                                 
         self.garea = GraphArea(renderer)
         self.add(self.garea)
         self.garea.show()
-    
+                        
     def key_press(self, widget, key_event):
         hadj = self.get_hadjustment()
         vadj = self.get_vadjustment()
         if hadj is None or vadj is None:
             return
+        
+        ctrl_clicked = key_event.state & gtk.gdk.CONTROL_MASK
+                     
+        keystr = None
+        keymap = {gtk.keysyms.Up : 'up', gtk.keysyms.Down : 'down',
+                  gtk.keysyms.Left : 'left', gtk.keysyms.Right : 'right'}
+        if key_event.keyval in keymap:        
+            keystr = keymap[key_event.keyval]
+        else:
+            return True
+                      
+        if ctrl_clicked:
+            keystr = 'ctrl-' + keystr
+            
+        if keystr is not None:
+            self._scroll_direction(keystr)
+            
+        return True
+    
+    def _scroll_direction(self, keystr):
+        hadj = self.get_hadjustment()
+        vadj = self.get_vadjustment()
+        if hadj is None or vadj is None:
+            return
             
         hupper = hadj.get_upper()
         hlower = hadj.get_lower()
@@ -334,8 +485,6 @@ class GraphWindow(gtk.ScrolledWindow):
         vsincr = vadj.get_step_increment()
         vpsize = vadj.get_page_size()
         
-        ctrl_clicked = key_event.state & gtk.gdk.CONTROL_MASK
-        
         adj_tuple = {'up' :     (vadj, -vsincr, 0, vval, max),
                      'ctrl-up' :    (vadj, -vpincr, 0, vval, max),
                      'down' :   (vadj, vsincr, vupper - vpsize, vval, min),
@@ -344,22 +493,24 @@ class GraphWindow(gtk.ScrolledWindow):
                      'ctrl-left' :  (hadj, -hpincr, 0, hval, max),
                      'right' :  (hadj, hsincr, hupper - hpsize, hval, min),
                      'ctrl-right' : (hadj, hpincr, hupper - hpsize, hval, min)}
-                     
-        keystr = None
-        keymap = {gtk.keysyms.Up : 'up', gtk.keysyms.Down : 'down',
-                  gtk.keysyms.Left : 'left', gtk.keysyms.Right : 'right'}
-        if key_event.keyval in keymap:        
-            keystr = keymap[key_event.keyval]
-                  
-        if ctrl_clicked:
-            keystr = 'ctrl-' + keystr
-            
-        if keystr is not None:
-            adj, inc, lim, val, extr = adj_tuple[keystr]
-            adj.set_value(extr(val + inc, lim))
-            
-        return True
         
+        adj, inc, lim, val, extr = adj_tuple[keystr]
+        adj.set_value(extr(val + inc, lim))
+        
+    def scroll(self, widget, scroll_event):
+        if scroll_event.state & gtk.gdk.CONTROL_MASK:
+            if scroll_event.direction == gtk.gdk.SCROLL_UP:
+                self.emit('request-zoom-in')
+            elif scroll_event.direction == gtk.gdk.SCROLL_DOWN:
+                self.emit('request-zoom-out')
+        else:
+            if scroll_event.direction == gtk.gdk.SCROLL_UP:
+                self._scroll_direction('up')
+            elif scroll_event.direction == gtk.gdk.SCROLL_DOWN:
+                self._scroll_direction('down')
+                
+        return True
+                
     def get_graph_area(self):
         return self.garea
                         
@@ -370,38 +521,76 @@ 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)
         self.connect('destroy', self.die)
         
-        self.file_menu = gtk.Menu()
-        self.quit_item = gtk.MenuItem('_Quit', True)
-        self.quit_item.connect('activate', self.quit_item_activate)
-        self.quit_item.show()
-        self.file_menu.append(self.quit_item)
+        file_menu = gtk.Menu()
+        view_menu = gtk.Menu()
+        
+        agr = gtk.AccelGroup()
+        self.add_accel_group(agr)
+        
+        quit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
+        key, mod = gtk.accelerator_parse('Q')
+        quit_item.add_accelerator('activate', agr, key, mod,
+            gtk.ACCEL_VISIBLE)
+        quit_item.connect('activate', self.quit_item_activate)
+        quit_item.show()
+        
+        file_menu.append(quit_item)
+        
+        file_item = gtk.MenuItem('_File', True)
+        file_item.set_submenu(file_menu)
+        file_item.show()
+        
+        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,
+            gtk.ACCEL_VISIBLE)
+        key, mod = gtk.accelerator_parse('<Ctrl>equal')  
+        zoom_in_item.add_accelerator('activate', agr, key, mod, 0) 
         
-        self.file_item = gtk.MenuItem('_File', True)
-        self.file_item.set_submenu(self.file_menu)
-        self.file_item.show()
+        zoom_in_item.connect('activate', self.zoom_in_item_activate)
+        zoom_in_item.show()
         
-        self.menu_bar = gtk.MenuBar()
-        self.menu_bar.append(self.file_item)
+        zoom_out_item = gtk.ImageMenuItem(gtk.STOCK_ZOOM_OUT, agr)
+        key, mod = gtk.accelerator_parse('<Ctrl>minus')
+        zoom_out_item.add_accelerator('activate', agr, key, mod,
+            gtk.ACCEL_VISIBLE)
+        key, mod = gtk.accelerator_parse('<Ctrl>underscore')  
+        zoom_out_item.add_accelerator('activate', agr, key, mod, 0) 
         
-        self.menu_bar.show()
+        zoom_out_item.connect('activate', self.zoom_out_item_activate)
+        zoom_out_item.show()
         
+        view_menu.append(zoom_in_item)
+        view_menu.append(zoom_out_item)
+        
+        view_item = gtk.MenuItem('_View', True)
+        view_item.set_submenu(view_menu)
+        view_item.show()
+        
+        menu_bar = gtk.MenuBar()
+        menu_bar.append(file_item)
+        menu_bar.append(view_item)
+                
+        menu_bar.show()
         self.vbox = gtk.VBox(False, 0)
         
         self.notebook = gtk.Notebook()
         
         self.notebook.last_page = -1
         self.notebook.connect('switch-page', self.switch_page)
-            
+        
         self.notebook.show()
         
         self.desc_label = gtk.Label('')
         self.desc_label.set_justify(gtk.JUSTIFY_LEFT)
         self.desc_label.show()
         
-        self.vbox.pack_start(self.menu_bar, False, False, 0)
+        self.vbox.pack_start(menu_bar, False, False, 0)
         self.vbox.pack_start(self.notebook, True, True, 0)
         self.vbox.pack_start(self.desc_label, False, False, 0)
         self.vbox.show()
@@ -412,18 +601,23 @@ class MainWindow(gtk.Window):
         
         self.show()
 
-    def connect_widgets(self, garea):
-        garea.connect('update-event-description', self.update_event_description)      
-        garea.connect('request-context-menu', self.request_context_menu)
-    
+    def connect_widgets(self, gwindow):
+        gwindow.get_graph_area().connect('update-event-description', self.update_event_description)      
+        gwindow.get_graph_area().connect('request-context-menu', self.request_context_menu)
+        gwindow.get_graph_area().connect('request-refresh-events', self.request_refresh_events)
+        gwindow.connect('request-zoom-in', self.zoom_in_item_activate)
+        gwindow.connect('request-zoom-out', self.zoom_out_item_activate)
+        
     def set_renderers(self, renderers):
         for i in range(0, self.notebook.get_n_pages()):
             self.notebook.remove_page(0)
         for title in renderers:
             gwindow = GraphWindow(renderers[title])
-            self.connect_widgets(gwindow.get_graph_area())
+            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()
         
     def switch_page(self, widget, page, page_num):
         if self.notebook.get_nth_page(self.notebook.last_page) is not None:
@@ -432,7 +626,7 @@ class MainWindow(gtk.Window):
             new_ofs = self.notebook.get_nth_page(page_num).get_graph_area().get_graph().get_origin()[0]
             new_value = old_value - old_ofs + new_ofs
             self.notebook.get_nth_page(page_num).get_hadjustment().set_value(new_value)
-        
+            
         self.notebook.last_page = page_num
         
     def update_event_description(self, widget, event, msg):
@@ -446,10 +640,27 @@ class MainWindow(gtk.Window):
         
         menu = GraphContextMenu(selected)
         menu.popup(None, None, None, button, time)
+    
+    def request_refresh_events(self, widget, sender, old, new, replace):
+        for i in range(0, self.notebook.get_n_pages()):
+            if self.notebook.get_nth_page(i).get_graph_area() is not sender: 
+                self.notebook.get_nth_page(i).get_graph_area().refresh_events(sender, old, new, replace)
+                break
+        for i in range(0, self.notebook.get_n_pages()):
+            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)
+                        
+    def zoom_in_item_activate(self, widget):
+        for i in range(0, self.notebook.get_n_pages()):
+            self.notebook.get_nth_page(i).get_graph_area().zoom_in()
+        
+    def zoom_out_item_activate(self, widget):
+        for i in range(0, self.notebook.get_n_pages()):
+            self.notebook.get_nth_page(i).get_graph_area().zoom_out()
         
     def quit_item_activate(self, widget):
         self.destroy()
-            
+                    
     def delete_event(self, widget, event, data=None):
         return False