Colorsgit add .! COLORSgit add .git add .geany index.txt

1 files changed, 210 insertions, 54 deletions

diff --git a/unit_trace/viz/viewer.py b/unit_trace/viz/viewer.py
index 5e707b8..33c84ff 100644
--- a/unit_trace/viz/viewer.py
+++ b/unit_trace/viz/viewer.py
@@ -4,7 +4,10 @@
 
 from schedule import *
 from renderer import *
+from graph import *
+from canvas import *
 from windows import *
+from format import *
 
 import pygtk
 import gtk
@@ -79,6 +82,23 @@ class GraphArea(gtk.DrawingArea):
         self.connect('button-release-event', self.button_release)
         self.connect('motion-notify-event', self.motion_notify)
 
+    def output_to_file(self, filename, ftype):
+        """Outputs the entire graph to a file."""
+        graph = self.renderer.get_graph()
+        surface = None
+        if ftype == 'png':
+            surface = ImageSurface()
+        elif ftype == 'svg':
+            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()
@@ -204,7 +224,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
@@ -216,7 +240,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:
@@ -228,20 +252,23 @@ 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):
-        max_layer = Canvas.BOTTOM_LAYER
-        for event in regions:
-            if event.get_layer() > max_layer:
-                max_layer = event.get_layer()
+        max_layer = -1
+        for layer in regions:
+            if layer > max_layer:
+                max_layer = layer
         return max_layer
 
     def _dirty_events(self, events):
         # if an event changed selected status, update the bounding area
         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,
+                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,
@@ -284,15 +311,14 @@ 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)
+        just_selected = graph.get_intersecting_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
         else:
             max_layer = self._find_max_layer(just_selected)
-
-            for event in just_selected:
+            for event in just_selected[max_layer]:
                 if event.get_layer() == max_layer:
                     the_event = event
                     break
@@ -331,9 +357,11 @@ class GraphArea(gtk.DrawingArea):
             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)
+                i_regs = graph.get_intersecting_regions(rx, ry, rwidth, rheight)
+                for layer in i_regs:
+                    for event in i_regs[layer]:
+                        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)
@@ -344,8 +372,10 @@ class GraphArea(gtk.DrawingArea):
             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)
+                i_regs = graph.get_intersecting_regions(rx, ry, rwidth, rheight)
+                for layer in i_regs:
+                    for event in i_regs[layer]:
+                        self._select_event(add_selected, event)
 
             self.band_rect = x, y, width, height
             self.emit('request-refresh-events', self, add_selected, remove_selected, False)
@@ -362,9 +392,9 @@ class GraphArea(gtk.DrawingArea):
             self.left_button_start_coor = (button_event.x, button_event.y)
             graph.render_surface(self.renderer.get_schedule(), \
                                  [(button_event.x, button_event.y, 0, 0)], True)
-
-            just_selected = graph.get_selected_regions(button_event.x, button_event.y, 0, 0)
-
+            
+            just_selected = graph.get_intersecting_regions(button_event.x, button_event.y, 0, 0)
+            
             max_layer = self._find_max_layer(just_selected)
 
             was_selected = self.renderer.get_schedule().get_selected()
@@ -382,21 +412,21 @@ class GraphArea(gtk.DrawingArea):
                 # 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):
+                if just_selected:
+                    for event in just_selected[max_layer]:
+                        if not (more_than_one == 1 and max_layer in was_selected \
+                                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 = {}
                 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]:
+                if just_selected:
+                    for event in just_selected[max_layer]:
+                        if max_layer in was_selected and event in was_selected[max_layer]:
                             self._select_event(remove_selected, event)
                         else:
                             self._select_event(add_selected, event)
@@ -566,40 +596,68 @@ 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)
 
         file_menu = gtk.Menu()
+        edit_menu = gtk.Menu()
         view_menu = gtk.Menu()
 
         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)
+        save_item.set_image(img)
+        key, mod = gtk.accelerator_parse('<Ctrl>S')
+        save_item.add_accelerator('activate', agr, key, mod,
+            gtk.ACCEL_VISIBLE)
+        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('Q')
+        key, mod = gtk.accelerator_parse('<Ctrl>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(save_item)
         file_menu.append(quit_item)
 
         file_item = gtk.MenuItem('_File', True)
         file_item.set_submenu(file_menu)
-        file_item.show()
 
-        self.move_item = gtk.ImageMenuItem('_Move to Time')
+        move_item = gtk.ImageMenuItem('_Move to Time')
         key, mod = gtk.accelerator_parse('<Ctrl>M')
-        self.move_item.add_accelerator('activate', agr, key, mod,
+        move_item.add_accelerator('activate', agr, key, mod,
             gtk.ACCEL_VISIBLE)
-        self.move_item.set_sensitive(False)
-
-        self.move_item.connect('activate', self.move_to_time_activate)
-        self.move_item.show()
+        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')
+        key, mod = gtk.accelerator_parse('<Ctrl>L')
+        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,
@@ -608,7 +666,6 @@ class MainWindow(gtk.Window):
         zoom_in_item.add_accelerator('activate', agr, key, mod, 0)
 
         zoom_in_item.connect('activate', self.zoom_in_item_activate)
-        zoom_in_item.show()
 
         zoom_out_item = gtk.ImageMenuItem(gtk.STOCK_ZOOM_OUT, agr)
         key, mod = gtk.accelerator_parse('<Ctrl>minus')
@@ -618,21 +675,19 @@ class MainWindow(gtk.Window):
         zoom_out_item.add_accelerator('activate', agr, key, mod, 0)
 
         zoom_out_item.connect('activate', self.zoom_out_item_activate)
-        zoom_out_item.show()
 
-        view_menu.append(self.move_item)
+        view_menu.append(move_item)
         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(edit_item)
         menu_bar.append(view_item)
 
-        menu_bar.show()
         self.vbox = gtk.VBox(False, 0)
 
         self.notebook = gtk.Notebook()
@@ -640,25 +695,24 @@ class MainWindow(gtk.Window):
         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_alignment(0.0, 0.0)
-        self.desc_label.show()
 
         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()
 
         self.add(self.vbox)
 
         self.info_win = InfoWindow()
-
+        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')
-        self.show()
+        self.show_all()
 
     def connect_widgets(self, gwindow):
         gwindow.get_graph_area().connect('update-event-description', self.update_event_description)
@@ -666,6 +720,7 @@ class MainWindow(gtk.Window):
         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)
+        gwindow.get_graph_area().connect('update-sel-changes', self.update_sel_changes)
 
     def set_renderers(self, renderers):
         for i in range(0, self.notebook.get_n_pages()):
@@ -675,15 +730,28 @@ 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()
 
         if self.notebook.get_n_pages() > 0:
-            self.move_item.set_sensitive(True)
+            for menu_item in self.sensitive_menu_items:
+                menu_item.set_sensitive(True)
         else:
-            self.move_item.set_sensitive(False)
-
+            for menu_item in self.sensitive_menu_items:
+                menu_item.set_sensitive(False)
 
+    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)    
+        
     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()
@@ -710,11 +778,12 @@ class MainWindow(gtk.Window):
         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()):
+            self.notebook.get_nth_page(i).get_graph_area().renderer.graph
             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)
 
@@ -760,6 +829,93 @@ class MainWindow(gtk.Window):
         for i in range(0, self.notebook.get_n_pages()):
             self.notebook.get_nth_page(i).get_graph_area().zoom_out()
 
+    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))
+        colorsel.set_previous_color(cur_color)
+        colorsel.set_current_color(cur_color)
+        colorsel.set_has_palette(True)
+
+        if self.color_dialog.run() == gtk.RESPONSE_OK:
+            color = colorsel.get_current_color()
+            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:
+                    filename += '.' + parts[0]
+                    if dialog.get_filter() is png_filter:
+                        ftype = 'png'
+                    elif dialog.get_filter() is svg_filter:
+                        ftype = 'svg'
+                    break
+                else:
+                    ftype = parts[-1]
+                    if ftype in ACCEPTED_TYPES:
+                        break
+                    else:
+                        err_dialog = gtk.MessageDialog(self, gtk.DIALOG_DESTROY_WITH_PARENT,
+                                                         gtk.MESSAGE_ERROR,
+                                                         gtk.BUTTONS_CLOSE,
+                                                         'File type "' + ftype + '" not recognized')
+                        err_dialog.set_title('File Type Error')
+                        err_dialog.run()
+                        err_dialog.destroy()
+            else:
+                filename = None
+                ftype = None
+                break
+                
+        if filename is not None:
+            cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)
+            dialog.get_window().set_cursor(cursor)
+            def idle_callback(dialog):
+                self.notebook.get_nth_page(self.notebook.last_page).get_graph_area().output_to_file(filename, ftype)
+                dialog.get_window().set_cursor(None)
+                dialog.destroy()
+            gobject.idle_add(idle_callback, dialog) # needed to get the cursor to display
+        else:    
+            dialog.destroy()
+        
     def quit_item_activate(self, widget):
         self.destroy()