# Copyright (c) 2013 ARM Limited # All rights reserved # # The license below extends only to copyright in the software and shall # not be construed as granting a license to any other intellectual # property including but not limited to intellectual property relating # to a hardware implementation of the functionality of the software # licensed hereunder. You may use the software subject to the license # terms below provided that you ensure that this notice is replicated # unmodified and in its entirety in all distributions of the software, # modified or unmodified, in source code or in binary form. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer; # redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution; # neither the name of the copyright holders nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import pygtk pygtk.require('2.0') import gtk import gobject import cairo import re from point import Point import parse import colours import model from model import Id, BlobModel, BlobDataSelect, special_state_chars import blobs class BlobView(object): """The canvas view of the pipeline""" def __init__(self, model): # A unit blob will appear at size blobSize inside a space of # size pitch. self.blobSize = Point(45.0, 45.0) self.pitch = Point(60.0, 60.0) self.origin = Point(50.0, 50.0) # Some common line definitions to cut down on arbitrary # set_line_widths self.thickLineWidth = 10.0 self.thinLineWidth = 4.0 self.midLineWidth = 6.0 # The scale from the units of pitch to device units (nominally # pixels for 1.0 to 1.0 self.masterScale = Point(1.0,1.0) self.model = model self.fillColour = colours.emptySlotColour self.timeIndex = 0 self.time = 0 self.positions = [] self.controlbar = None # The sequence number selector state self.dataSelect = BlobDataSelect() # Offset of this view's time from self.time used for miniviews # This is actually an offset of the index into the array of times # seen in the event file) self.timeOffset = 0 # Maximum view size for initial window mapping self.initialHeight = 600.0 # Overlays are speech bubbles explaining blob data self.overlays = [] self.da = gtk.DrawingArea() def draw(arg1, arg2): self.redraw() self.da.connect('expose_event', draw) # Handy offsets from the blob size self.blobIndent = (self.pitch - self.blobSize).scale(0.5) self.blobIndentFactor = self.blobIndent / self.pitch def add_control_bar(self, controlbar): """Add a BlobController to this view""" self.controlbar = controlbar def draw_to_png(self, filename): """Draw the view to a PNG file""" surface = cairo.ImageSurface( cairo.FORMAT_ARGB32, self.da.get_allocation().width, self.da.get_allocation().height) cr = gtk.gdk.CairoContext(cairo.Context(surface)) self.draw_to_cr(cr) surface.write_to_png(filename) def draw_to_cr(self, cr): """Draw to a given CairoContext""" cr.set_source_color(colours.backgroundColour) cr.set_line_width(self.thickLineWidth) cr.paint() cr.save() cr.scale(*self.masterScale.to_pair()) cr.translate(*self.origin.to_pair()) positions = [] # {} # Draw each blob for blob in self.model.blobs: blob_event = self.model.find_unit_event_by_time( blob.unit, self.time) cr.save() pos = blob.render(cr, self, blob_event, self.dataSelect, self.time) cr.restore() if pos is not None: (centre, size) = pos positions.append((blob, centre, size)) # Draw all the overlays over the top for overlay in self.overlays: overlay.show(cr) cr.restore() return positions def redraw(self): """Redraw the whole view""" buffer = cairo.ImageSurface( cairo.FORMAT_ARGB32, self.da.get_allocation().width, self.da.get_allocation().height) cr = gtk.gdk.CairoContext(cairo.Context(buffer)) positions = self.draw_to_cr(cr) # Assume that blobs are in order for depth so we want to # hit the frontmost blob first if we search by position positions.reverse() self.positions = positions # Paint the drawn buffer onto the DrawingArea dacr = self.da.window.cairo_create() dacr.set_source_surface(buffer, 0.0, 0.0) dacr.paint() buffer.finish() def set_time_index(self, time): """Set the time index for the view. A time index is an index into the model's times array of seen event times""" self.timeIndex = time + self.timeOffset if len(self.model.times) != 0: if self.timeIndex >= len(self.model.times): self.time = self.model.times[len(self.model.times) - 1] else: self.time = self.model.times[self.timeIndex] else: self.time = 0 def get_pic_size(self): """Return the size of ASCII-art picture of the pipeline scaled by the blob pitch""" return (self.origin + self.pitch * (self.model.picSize + Point(1.0,1.0))) def set_da_size(self): """Set the DrawingArea size after scaling""" self.da.set_size_request(10 , int(self.initialHeight)) class BlobController(object): """The controller bar for the viewer""" def __init__(self, model, view, defaultEventFile="", defaultPictureFile=""): self.model = model self.view = view self.playTimer = None self.filenameEntry = gtk.Entry() self.filenameEntry.set_text(defaultEventFile) self.pictureEntry = gtk.Entry() self.pictureEntry.set_text(defaultPictureFile) self.timeEntry = None self.defaultEventFile = defaultEventFile self.startTime = None self.endTime = None self.otherViews = [] def make_bar(elems): box = gtk.HBox(homogeneous=False, spacing=2) box.set_border_width(2) for widget, signal, handler in elems: if signal is not None: widget.connect(signal, handler) box.pack_start(widget, False, True, 0) return box self.timeEntry = gtk.Entry() t = gtk.ToggleButton('T') t.set_active(False) s = gtk.ToggleButton('S') s.set_active(True) p = gtk.ToggleButton('P') p.set_active(True) l = gtk.ToggleButton('L') l.set_active(True) f = gtk.ToggleButton('F') f.set_active(True) e = gtk.ToggleButton('E') e.set_active(True) # Should really generate this from above self.view.dataSelect.ids = set("SPLFE") self.bar = gtk.VBox() self.bar.set_homogeneous(False) row1 = make_bar([ (gtk.Button('Start'), 'clicked', self.time_start), (gtk.Button('End'), 'clicked', self.time_end), (gtk.Button('Back'), 'clicked', self.time_back), (gtk.Button('Forward'), 'clicked', self.time_forward), (gtk.Button('Play'), 'clicked', self.time_play), (gtk.Button('Stop'), 'clicked', self.time_stop), (self.timeEntry, 'activate', self.time_set), (gtk.Label('Visible ids:'), None, None), (t, 'clicked', self.toggle_id('T')), (gtk.Label('/'), None, None), (s, 'clicked', self.toggle_id('S')), (gtk.Label('.'), None, None), (p, 'clicked', self.toggle_id('P')), (gtk.Label('/'), None, None), (l, 'clicked', self.toggle_id('L')), (gtk.Label('/'), None, None), (f, 'clicked', self.toggle_id('F')), (gtk.Label('.'), None, None), (e, 'clicked', self.toggle_id('E')), (self.filenameEntry, 'activate', self.load_events), (gtk.Button('Reload'), 'clicked', self.load_events) ]) self.bar.pack_start(row1, False, True, 0) self.set_time_index(0) def toggle_id(self, id): """One of the sequence number selector buttons has been toggled""" def toggle(button): if button.get_active(): self.view.dataSelect.ids.add(id) else: self.view.dataSelect.ids.discard(id) # Always leave one thing visible if len(self.view.dataSelect.ids) == 0: self.view.dataSelect.ids.add(id) button.set_active(True) self.view.redraw() return toggle def set_time_index(self, time): """Set the time index in the view""" self.view.set_time_index(time) for view in self.otherViews: view.set_time_index(time) view.redraw() self.timeEntry.set_text(str(self.view.time)) def time_start(self, button): """Start pressed""" self.set_time_index(0) self.view.redraw() def time_end(self, button): """End pressed""" self.set_time_index(len(self.model.times) - 1) self.view.redraw() def time_forward(self, button): """Step forward pressed""" self.set_time_index(min(self.view.timeIndex + 1, len(self.model.times) - 1)) self.view.redraw() gtk.gdk.flush() def time_back(self, button): """Step back pressed""" self.set_time_index(max(self.view.timeIndex - 1, 0)) self.view.redraw() def time_set(self, entry): """Time dialogue changed. Need to find a suitable time <= the entry's time""" newTime = self.model.find_time_index(int(entry.get_text())) self.set_time_index(newTime) self.view.redraw() def time_step(self): """Time step while playing""" if not self.playTimer \ or self.view.timeIndex == len(self.model.times) - 1: self.time_stop(None) return False else: self.time_forward(None) return True def time_play(self, play): """Automatically advance time every 100 ms""" if not self.playTimer: self.playTimer = gobject.timeout_add(100, self.time_step) def time_stop(self, play): """Stop play pressed""" if self.playTimer: gobject.source_remove(self.playTimer) self.playTimer = None def load_events(self, button): """Reload events file""" self.model.load_events(self.filenameEntry.get_text(), startTime=self.startTime, endTime=self.endTime) self.set_time_index(min(len(self.model.times) - 1, self.view.timeIndex)) self.view.redraw() class Overlay(object): """An Overlay is a speech bubble explaining the data in a blob""" def __init__(self, model, view, point, blob): self.model = model self.view = view self.point = point self.blob = blob def find_event(self): """Find the event for a changing time and a fixed blob""" return self.model.find_unit_event_by_time(self.blob.unit, self.view.time) def show(self, cr): """Draw the overlay""" event = self.find_event() if event is None: return insts = event.find_ided_objects(self.model, self.blob.picChar, False) cr.set_line_width(self.view.thinLineWidth) cr.translate(*(Point(0.0,0.0) - self.view.origin).to_pair()) cr.scale(*(Point(1.0,1.0) / self.view.masterScale).to_pair()) # Get formatted data from the insts to format into a table lines = list(inst.table_line() for inst in insts) text_size = 10.0 cr.set_font_size(text_size) def text_width(str): xb, yb, width, height, dx, dy = cr.text_extents(str) return width # Find the maximum number of columns and the widths of each column num_columns = 0 for line in lines: num_columns = max(num_columns, len(line)) widths = [0] * num_columns for line in lines: for i in xrange(0, len(line)): widths[i] = max(widths[i], text_width(line[i])) # Calculate the size of the speech bubble column_gap = 1 * text_size id_width = 6 * text_size total_width = sum(widths) + id_width + column_gap * (num_columns + 1) gap_step = Point(1.0, 0.0).scale(column_gap) text_point = self.point text_step = Point(0.0, text_size) size = Point(total_width, text_size * len(insts)) # Draw the speech bubble blobs.speech_bubble(cr, self.point, size, text_size) cr.set_source_color(colours.backgroundColour) cr.fill_preserve() cr.set_source_color(colours.black) cr.stroke() text_point += Point(1.0,1.0).scale(2.0 * text_size) id_size = Point(id_width, text_size) # Draw the rows in the table for i in xrange(0, len(insts)): row_point = text_point inst = insts[i] line = lines[i] blobs.striped_box(cr, row_point + id_size.scale(0.5), id_size, inst.id.to_striped_block(self.view.dataSelect)) cr.set_source_color(colours.black) row_point += Point(1.0, 0.0).scale(id_width) row_point += text_step # Draw the columns of each row for j in xrange(0, len(line)): row_point += gap_step cr.move_to(*row_point.to_pair()) cr.show_text(line[j]) row_point += Point(1.0, 0.0).scale(widths[j]) text_point += text_step class BlobWindow(object): """The top-level window and its mouse control""" def __init__(self, model, view, controller): self.model = model self.view = view self.controller = controller self.controlbar = None self.window = None self.miniViewCount = 0 def add_control_bar(self, controlbar): self.controlbar = controlbar def show_window(self): self.window = gtk.Window() self.vbox = gtk.VBox() self.vbox.set_homogeneous(False) if self.controlbar: self.vbox.pack_start(self.controlbar, False, True, 0) self.vbox.add(self.view.da) if self.miniViewCount > 0: self.miniViews = [] self.miniViewHBox = gtk.HBox(homogeneous=True, spacing=2) # Draw mini views for i in xrange(1, self.miniViewCount + 1): miniView = BlobView(self.model) miniView.set_time_index(0) miniView.masterScale = Point(0.1, 0.1) miniView.set_da_size() miniView.timeOffset = i + 1 self.miniViews.append(miniView) self.miniViewHBox.pack_start(miniView.da, False, True, 0) self.controller.otherViews = self.miniViews self.vbox.add(self.miniViewHBox) self.window.add(self.vbox) def show_event(picChar, event): print '**** Comments for', event.unit, \ 'at time', self.view.time for name, value in event.pairs.iteritems(): print name, '=', value for comment in event.comments: print comment if picChar in event.visuals: # blocks = event.visuals[picChar].elems() print '**** Colour data' objs = event.find_ided_objects(self.model, picChar, True) for obj in objs: print ' '.join(obj.table_line()) def clicked_da(da, b): point = Point(b.x, b.y) overlay = None for blob, centre, size in self.view.positions: if point.is_within_box((centre, size)): event = self.model.find_unit_event_by_time(blob.unit, self.view.time) if event is not None: if overlay is None: overlay = Overlay(self.model, self.view, point, blob) show_event(blob.picChar, event) if overlay is not None: self.view.overlays = [overlay] else: self.view.overlays = [] self.view.redraw() # Set initial size and event callbacks self.view.set_da_size() self.view.da.add_events(gtk.gdk.BUTTON_PRESS_MASK) self.view.da.connect('button-press-event', clicked_da) self.window.connect('destroy', lambda(widget): gtk.main_quit()) def resize(window, event): """Resize DrawingArea to match new window size""" size = Point(float(event.width), float(event.height)) proportion = size / self.view.get_pic_size() # Preserve aspect ratio daScale = min(proportion.x, proportion.y) self.view.masterScale = Point(daScale, daScale) self.view.overlays = [] self.view.da.connect('configure-event', resize) self.window.show_all()