grid.py

Go to the documentation of this file.

#!/usr/bin/env python3
 
 
import cairo
import sys
import re
import gtk
 
 
 
class DataRange:
    
    def __init__(self, start = 0, end = 0, value = ''):
        """! Initializer
        @param self this object
        @param start start
        @param end end
        @param value value
        @return none
        """
        self.startstart = start
        self.endend = end
        self.valuevalue = value
 
class EventString:
    
    def __init__(self, at = 0, value = ''):
        """! Initializer
        @param self this object
        @param at you
        @param value value
        @return none
        """
        self.atat = at
        self.valuevalue = value
 
class EventFloat:
    
    def __init__(self, at = 0, value = 0.0):
        """! Initializer
        @param self this object
        @param at you
        @param value value
        @return none
        """
        self.atat = at
        self.valuevalue = value
 
class EventInt:
    
    def __init__(self, at = 0, value = 0.0):
        """! Initializer
        @param self this object
        @param at you
        @param value value
        @return none
        """
        self.atat = at
        self.valuevalue = value
def ranges_cmp(a, b):
    diff = a.start - b.start
    if diff < 0:
        return -1
    elif diff > 0:
        return +1
    else:
        return 0
def events_cmp(a, b):
    diff = a.at - b.at
    if diff < 0:
        return -1
    elif diff > 0:
        return +1
    else:
        return 0
 
class TimelineDataRange:
    
    def __init__(self, name = ''):
        """! Initializer
        @param self this object
        @param name name
        @return none
        """
        self.namename = name
        self.rangesranges = []
        return
    def __search(self, key):
        """! Search
        @param self this object
        @param key key
        @return index if found or -1 if not found
        """
        l = 0
        u = len(self.rangesranges)-1
        while l <= u:
            i = int((l + u) / 2)
            if key >= self.rangesranges[i].start and key <= self.rangesranges[i].end:
                return i
            elif key < self.rangesranges[i].start:
                u = i - 1
            else:
                # key > self.ranges[i].end
                l = i + 1
        return - 1
    def add_range(self, range):
        """! Add range
        @param self this object
        @param range range
        @return none
        """
        self.rangesranges.append(range)
    def get_all(self):
        """! Get all ranges
        @param self this object
        @return the ranges
        """
        return self.rangesranges
    def get_ranges(self, start, end):
        """! Get selected ranges
        @param self this object
        @param start range start
        @param end range end
        @return the range or and empty list
        """
        s = self.__search__search(start)
        e = self.__search__search(end)
        if s == -1 and e == -1:
            return []
        elif s == -1:
            return self.rangesranges[0:e + 1]
        elif e == -1:
            return self.rangesranges[s:len(self.rangesranges)]
        else:
            return self.rangesranges[s:e + 1]
    def get_ranges_bounds(self, start, end):
        """! Get ranges bounds
        @param self this object
        @param start range start
        @param end range end
        @return range
        """
        s = self.__search__search(start)
        e = self.__search__search(end)
        if s == -1 and e == -1:
            return(0, 0)
        elif s == -1:
            return(0, e + 1)
        elif e == -1:
            return(s, len(self.rangesranges))
        else:
            return(s, e + 1)
    def sort(self):
        """! Sort ranges
        @param self this object
        @return none
        """
        self.rangesranges.sort(ranges_cmp)
    def get_bounds(self):
        """! Get bounds
        @param self this object
        @return the bounds
        """
        if len(self.rangesranges) > 0:
            lo = self.rangesranges[0].start
            hi = self.rangesranges[len(self.rangesranges)-1].end
            return(lo, hi)
        else:
            return(0, 0)
 
class TimelineEvent:
    
    def __init__(self, name = ''):
        """! Get ranges bounds
        @param self this object
        @param name name
        @return none
        """
        self.namename = name
        self.eventsevents = []
    def __search(self, key):
        """! Search function
        @param self this object
        @param key the key
        @return event index
        """
        l = 0
        u = len(self.eventsevents)-1
        while l <= u:
            i = int((l + u) / 2)
            if key == self.eventsevents[i].at:
                return i
            elif key < self.eventsevents[i].at:
                u = i - 1
            else:
                # key > self.events[i].at
                l = i + 1
        return l
    def add_event(self, event):
        """! Add Event
        @param self this object
        @param event event to add
        @return none
        """
        self.eventsevents.append(event)
    def get_events(self, start, end):
        """! Get Events
        @param self this object
        @param start starting event
        @param end ending event
        @return the events
        """
        s = self.__search__search(start)
        e = self.__search__search(end)
        return self.eventsevents[s:e + 1]
    def get_events_bounds(self, start, end):
        """! Get Events Bounds
        @param self this object
        @param start starting event
        @param end ending event
        @return event bounds
        """
        s = self.__search__search(start)
        e = self.__search__search(end)
        return(s, e + 1)
    def sort(self):
        """! Sort function
        @param self this object
        @return none
        """
        self.eventsevents.sort(events_cmp)
    def get_bounds(self):
        """! Get Bounds
        @param self this object
        @return the bounds
        """
        if len(self.eventsevents) > 0:
            lo = self.eventsevents[0].at
            hi = self.eventsevents[-1].at
            return(lo, hi)
        else:
            return(0, 0)
 
 
class Timeline:
    
    def __init__(self, name = ''):
        """! Initializer
        @param self this object
        @param name name
        @return none
        """
        self.rangesranges = []
        self.event_strevent_str = []
        self.event_intevent_int = []
        self.namename = name
    def get_range(self, name):
        """! Get range
        @param self this object
        @param name name
        @return the range
        """
        for range in self.rangesranges:
            if range.name == name:
                return range
        timeline = TimelineDataRange(name)
        self.rangesranges.append(timeline)
        return timeline
    def get_event_str(self, name):
        """! Get Event String
        @param self this object
        @param name name
        @return the event string
        """
        for event_str in self.event_strevent_str:
            if event_str.name == name:
                return event_str
        timeline = TimelineEvent(name)
        self.event_strevent_str.append(timeline)
        return timeline
    def get_event_int(self, name):
        """! Get Event Int
        @param self this object
        @param name name
        @return eevent int
        """
        for event_int in self.event_intevent_int:
            if event_int.name == name:
                return event_int
        timeline = TimelineEvent(name)
        self.event_intevent_int.append(timeline)
        return timeline
    def get_ranges(self):
        """! Get Ranges
        @param self this object
        @return the ranges
        """
        return self.rangesranges
    def get_events_str(self):
        """! Get Events string
        @param self this object
        @return event string
        """
        return self.event_strevent_str
    def get_events_int(self):
        """! Get Events int
        @param self this object
        @return evrnt int
        """
        return self.event_intevent_int
    def sort(self):
        """! Sort the ranges and events
        @param self this object
        @return none
        """
        for range in self.rangesranges:
            range.sort()
        for event in self.event_intevent_int:
            event.sort()
        for event in self.event_strevent_str:
            event.sort()
    def get_bounds(self):
        """! Get Bounds
        @param self this object
        @return the bounds
        """
        lo = 0
        hi = 0
        for range in self.rangesranges:
            (range_lo, range_hi) = range.get_bounds()
            if range_lo < lo:
                lo = range_lo
            if range_hi > hi:
                hi = range_hi
        for event_str in self.event_strevent_str:
            (ev_lo, ev_hi) = event_str.get_bounds()
            if ev_lo < lo:
                lo = ev_lo
            if ev_hi > hi:
                hi = ev_hi
        for event_int in self.event_intevent_int:
            (ev_lo, ev_hi) = event_int.get_bounds()
            if ev_lo < lo:
                lo = ev_lo
            if ev_hi > hi:
                hi = ev_hi
        return(lo, hi)
 
 
class Timelines:
    
    def __init__(self):
        """ Initializer
        @param self: this object
        """
        self.timelinestimelines = []
    def get(self, name):
        """! Get Timeline
        @param self this object
        @param name name
        @return the timeline for the name
        """
        for timeline in self.timelinestimelines:
            if timeline.name == name:
                return timeline
        timeline = Timeline(name)
        self.timelinestimelines.append(timeline)
        return timeline
    def get_all(self):
        """! Get All Timeline
        @param self this object
        @return all timelines
        """
        return self.timelinestimelines
    def sort(self):
        """! Sort the timelines
        @param self this object
        @return none
        """
        for timeline in self.timelinestimelines:
            timeline.sort()
    def get_bounds(self):
        """! Get Bounds
        @param self this object
        @return the bounds for all timelines
        """
        lo = 0
        hi = 0
        for timeline in self.timelinestimelines:
            (t_lo, t_hi) = timeline.get_bounds()
            if t_lo < lo:
                lo = t_lo
            if t_hi > hi:
                hi = t_hi
        return(lo, hi)
    def get_all_range_values(self):
        """! Get All Ranges
        @param self this object
        @return the keys for all ranges
        """
        range_values = {}
        for timeline in self.timelinestimelines:
            for ranges in timeline.get_ranges():
                for ran in ranges.get_all():
                    range_values[ran.value] = 1
        return range_values.keys()
 
 
class Color:
    
    def __init__(self, r = 0.0, g = 0.0, b = 0.0):
        """! Initializer
        @param self: this object
        @param r: red
        @param g: green
        @param b: blue
        @return none
        """
        self.rr = r
        self.gg = g
        self.bb = b
    def set(self, r, g, b):
        """! Set color
        @param self: this object
        @param r: red
        @param g: green
        @param b: blue
        @return none
        """
        self.rr = r
        self.gg = g
        self.bb = b
 
 
class Colors:
    
    default_colors = [Color(1, 0, 0), Color(0, 1, 0), Color(0, 0, 1), Color(1, 1, 0), Color(1, 0, 1), Color(0, 1, 1)]
    def __init__(self):
        """! Initializer
        @param self this object
        @return none
        """
        self.__colors__colors = {}
    def add(self, name, color):
        """! Add
        @param self this object
        @param name name of the color
        @param color color value
        @return none
        """
        self.__colors__colors[name] = color
    def lookup(self, name):
        """! Lookup name
        @param self this object
        @param name name
        @return named color
        """
        if not self.__colors__colors.has_key(name):
            self.addadd(name, self.default_colorsdefault_colors.pop())
        return self.__colors__colors.get(name)
 
 
class TopLegendRenderer:
    
    def __init__(self):
        """! Initializer
        @param self this object
        @return none
        """
        self.__padding__padding = 10
    def set_padding(self, padding):
        """! Set padding
        @param self this object
        @param padding padding
        @return none
        """
        self.__padding__padding = padding
    def set_legends(self, legends, colors):
        """! Set padding
        @param self this object
        @param legends legends
        @param colors colors
        @return none
        """
        self.__legends__legends = legends
        self.__colors__colors = colors
    def layout(self, width):
        """! Set padding
        @param self this object
        @param width width
        @return none
        """
        self.__width__width = width
        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)
        ctx = cairo.Context(surface)
        line_height = 0
        total_height = self.__padding__padding
        line_used = self.__padding__padding
        for legend in self.__legends__legends:
            (t_width, t_height) = ctx.text_extents(legend)[2:4]
            item_width = self.__padding__padding + self.__padding__padding + t_width + self.__padding__padding
            item_height = t_height + self.__padding__padding
            if item_height > line_height:
                line_height = item_height
            if line_used + item_width > self.__width__width:
                line_used = self.__padding__padding + item_width
                total_height += line_height
            else:
                line_used += item_width
            x = line_used - item_width
        total_height += line_height
        self.__height__height = total_height
 
    def get_height(self):
        """! Set padding
        @param self this object
        @return height
        """
        return self.__height__height
    def draw(self, ctx):
        """! Set padding
        @param self this object
        @param ctx ctx
        @return none
        """
        i = 0
        line_height = 0
        total_height = self.__padding__padding
        line_used = self.__padding__padding
        for legend in self.__legends__legends:
            (t_width, t_height) = ctx.text_extents(legend)[2:4]
            item_width = self.__padding__padding + self.__padding__padding + t_width + self.__padding__padding
            item_height = t_height + self.__padding__padding
            if item_height > line_height:
                line_height = item_height
            if line_used + item_width > self.__width__width:
                line_used = self.__padding__padding + item_width
                total_height += line_height
            else:
                line_used += item_width
            x = line_used - item_width
            ctx.rectangle(x, total_height, self.__padding__padding, self.__padding__padding)
            ctx.set_source_rgb(0, 0, 0)
            ctx.set_line_width(2)
            ctx.stroke_preserve()
            ctx.set_source_rgb(self.__colors__colors[i].r,
                               self.__colors__colors[i].g,
                               self.__colors__colors[i].b)
            ctx.fill()
            ctx.move_to(x + self.__padding__padding*2, total_height + t_height)
            ctx.set_source_rgb(0, 0, 0)
            ctx.show_text(legend)
            i += 1
 
        return
 
 
class TimelinesRenderer:
    
    def __init__(self):
        """! Initializer
        @param self this object
        @return none
        """
        self.paddingpadding = 10
        return
    def get_height(self):
        """! Get Height
        @param self this object
        @return height
        """
        return self.heightheight
    def set_timelines(self, timelines, colors):
        """! Set Timelines
        @param self this object
        @param timelines timelines
        @param colors colors
        @return none
        """
        self.timelinestimelines = timelines
        self.colorscolors = colors
    def set_render_range(self, start, end):
        """! Set Render Range
        @param self this object
        @param start start
        @param end end
        @return none
        """
        self.startstart = start
        self.endend = end
    def get_data_x_start(self):
        """! Get Data X Start
        @param self: this object
        @return X start
        """
        return self.paddingpadding / 2 + self.left_widthleft_width + self.paddingpadding + self.right_widthright_width + self.paddingpadding / 2
    def layout(self, width):
        """! Get Data X Start
        @param self this object
        @param width width
        @return none
        """
        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)
        ctx = cairo.Context(surface)
        max_text_height = ctx.text_extents("ABCDEFGHIJKLMNOPQRSTUVWXYZabcedefghijklmnopqrstuvwxyz0123456789")[3]
 
        left_width = 0
        right_width = 0
        left_n_lines = 0
        range_n = 0
        eventint_n = 0
        eventstr_n = 0
        for timeline in self.timelinestimelines.get_all():
            left_n_lines += 1
            t_width = ctx.text_extents(timeline.name)[2]
            left_width = max(left_width, t_width)
            for rang in timeline.get_ranges():
                t_width = ctx.text_extents(rang.name)[2]
                right_width = max(right_width, t_width)
                range_n += 1
            for events_int in timeline.get_events_int():
                t_width = ctx.text_extents(events_int.name)[2]
                right_width = max(right_width, t_width)
                eventint_n += 1
            for events_str in timeline.get_events_str():
                t_width = ctx.text_extents(events_str.name)[2]
                right_width = max(right_width, t_width)
                eventstr_n += 1
 
        left_height = left_n_lines * max_text_height + (left_n_lines - 1) * self.paddingpadding
        right_n_lines = range_n + eventint_n + eventstr_n
        right_height = (right_n_lines - 1) * self.paddingpadding + right_n_lines * max_text_height
        right_data_height = (eventint_n + eventstr_n) * (max_text_height + 5) + range_n * 10
        right_data_height += (right_n_lines - 1) * self.paddingpadding
 
        height = max(left_height, right_height)
        height = max(height, right_data_height)
 
        self.left_widthleft_width = left_width
        self.right_widthright_width = right_width
        self.max_text_heightmax_text_height = max_text_height
        self.widthwidth = width
        self.heightheight = height + self.paddingpadding
    def draw_line(self, ctx, x, y, width, height):
        """! Draw Line
        @param self this object
        @param ctx ctx
        @param x x
        @param y y
        @param width width
        @param height height
        @return none
        """
        ctx.move_to(x, y)
        ctx.rel_line_to(width, height)
        ctx.close_path()
        ctx.set_operator(cairo.OPERATOR_SOURCE)
        ctx.set_line_width(1.0)
        ctx.set_source_rgb(0, 0, 0)
        ctx.stroke()
    def draw_events(self, ctx, events, x, y, width, height):
        """! Draw Event
        @param self this object
        @param ctx ctx
        @param events events
        @param x x
        @param y y
        @param width width
        @param height height
        @return none
        """
        if (self.grey_backgroundgrey_background % 2) == 0:
            ctx.rectangle(x, y - self.paddingpadding / 2,
                          width, height + self.paddingpadding)
            ctx.set_source_rgb(0.9, 0.9, 0.9)
            ctx.fill()
        last_x_drawn = int(x)
        (lo, hi) = events.get_events_bounds(self.startstart, self.endend)
        for event in events.events[lo:hi]:
            real_x = int(x + (event.at - self.startstart) * width / (self.endend - self.startstart))
            if real_x > last_x_drawn + 2:
                ctx.rectangle(real_x, y, 1, 1)
                ctx.set_source_rgb(1, 0, 0)
                ctx.stroke()
                ctx.move_to(real_x, y + self.max_text_heightmax_text_height)
                ctx.set_source_rgb(0, 0, 0)
                ctx.show_text(str(event.value))
                last_x_drawn = real_x
        self.grey_backgroundgrey_background += 1
    def draw_ranges(self, ctx, ranges, x, y, width, height):
        """! Draw Ranges
        @param self this object
        @param ctx ctx
        @param ranges ranges
        @param x x
        @param y y
        @param width width
        @param height height
        @return none
        """
        if (self.grey_backgroundgrey_background % 2) == 0:
            ctx.rectangle(x, y - self.paddingpadding / 2,
                          width, height + self.paddingpadding)
            ctx.set_source_rgb(0.9, 0.9, 0.9)
            ctx.fill()
        last_x_drawn = int(x - 1)
        (lo, hi) = ranges.get_ranges_bounds(self.startstart, self.endend)
        for data_range in ranges.ranges[lo:hi]:
            s = max(data_range.start, self.startstart)
            e = min(data_range.end, self.endend)
            x_start = int(x + (s - self.startstart) * width / (self.endend - self.startstart))
            x_end = int(x + (e - self.startstart) * width / (self.endend - self.startstart))
            if x_end > last_x_drawn:
                ctx.rectangle(x_start, y, x_end - x_start, 10)
                ctx.set_source_rgb(0, 0, 0)
                ctx.stroke_preserve()
                color = self.colorscolors.lookup(data_range.value)
                ctx.set_source_rgb(color.r, color.g, color.b)
                ctx.fill()
                last_x_drawn = x_end
 
        self.grey_backgroundgrey_background += 1
 
    def draw(self, ctx):
        """! Draw
        @param self this object
        @param ctx ctx
        @return none
        """
        timeline_top = 0
        top_y = self.paddingpadding / 2
        left_x_start = self.paddingpadding / 2
        left_x_end = left_x_start + self.left_widthleft_width
        right_x_start = left_x_end + self.paddingpadding
        right_x_end = right_x_start + self.right_widthright_width
        data_x_start = right_x_end + self.paddingpadding / 2
        data_x_end = self.widthwidth
        data_width = data_x_end - data_x_start
        cur_y = top_y
        self.draw_linedraw_line(ctx, 0, 0, self.widthwidth, 0)
        self.grey_backgroundgrey_background = 1
        for timeline in self.timelinestimelines.get_all():
            (y_bearing, t_width, t_height) = ctx.text_extents(timeline.name)[1:4]
            ctx.move_to(left_x_start, cur_y + self.max_text_heightmax_text_height - (t_height + y_bearing))
            ctx.show_text(timeline.name);
            for events_int in timeline.get_events_int():
                (y_bearing, t_width, t_height) = ctx.text_extents(events_int.name)[1:4]
                ctx.move_to(right_x_start, cur_y + self.max_text_heightmax_text_height - (t_height + y_bearing))
                ctx.show_text(events_int.name)
                self.draw_eventsdraw_events(ctx, events_int, data_x_start, cur_y, data_width, self.max_text_heightmax_text_height + 5)
                cur_y += self.max_text_heightmax_text_height + 5 + self.paddingpadding
                self.draw_linedraw_line(ctx, right_x_start - self.paddingpadding / 2, cur_y - self.paddingpadding / 2,
                               self.right_widthright_width + self.paddingpadding, 0)
 
            for events_str in timeline.get_events_str():
                (y_bearing, t_width, t_height) = ctx.text_extents(events_str.name)[1:4]
                ctx.move_to(right_x_start, cur_y + self.max_text_heightmax_text_height - (t_height + y_bearing))
                ctx.show_text(events_str.name)
                self.draw_eventsdraw_events(ctx, events_str, data_x_start, cur_y, data_width, self.max_text_heightmax_text_height + 5)
                cur_y += self.max_text_heightmax_text_height + 5 + self.paddingpadding
                self.draw_linedraw_line(ctx, right_x_start - self.paddingpadding / 2, cur_y - self.paddingpadding / 2,
                               self.right_widthright_width + self.paddingpadding, 0)
            for ranges in timeline.get_ranges():
                (y_bearing, t_width, t_height) = ctx.text_extents(ranges.name)[1:4]
                ctx.move_to(right_x_start, cur_y + self.max_text_heightmax_text_height - (t_height + y_bearing))
                ctx.show_text(ranges.name)
                self.draw_rangesdraw_ranges(ctx, ranges, data_x_start, cur_y, data_width, 10)
                cur_y += self.max_text_heightmax_text_height + self.paddingpadding
                self.draw_linedraw_line(ctx, right_x_start - self.paddingpadding / 2, cur_y - self.paddingpadding / 2,
                               self.right_widthright_width + self.paddingpadding, 0)
            self.draw_linedraw_line(ctx, 0, cur_y - self.paddingpadding / 2,
                           self.widthwidth, 0)
        bot_y = cur_y - self.paddingpadding / 2
        self.draw_linedraw_line(ctx, left_x_end + self.paddingpadding / 2, 0,
                       0, bot_y)
        self.draw_linedraw_line(ctx, right_x_end + self.paddingpadding / 2, 0,
                       0, bot_y)
        return
 
 
class ScaleRenderer:
    
    def __init__(self):
        """! Initializer
        @param self this object
        @return none
        """
        self.__top__top = 0
        return
    def set_bounds(self, lo, hi):
        """! Set Bounds
        @param self this object
        @param lo lo
        @param hi hi
        @return none
        """
        self.__lo__lo = lo
        self.__hi__hi = hi
    def get_position(self, x):
        """! Get Position
        @param self this object
        @param x x
        @return real x
        """
        real_x = (x - self.__lo__lo ) * self.__width__width / (self.__hi__hi - self.__lo__lo)
        return real_x
    def set_top(self):
        """! Set Top
        @param self this object
        @return none
        """
        self.__top__top = 1
    def set_bot(self):
        """! Set Bottom
        @param self this object
        @return none
        """
        self.__top__top = 0
    def layout(self, width):
        """! Layout
        @param self this object
        @param width width
        @return none
        """
        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)
        ctx = cairo.Context(surface)
 
        # calculate scale delta
        data_delta = self.__hi__hi - self.__lo__lo
        closest = 1
        while (closest*10) < data_delta:
            closest *= 10
        if (data_delta / closest) == 0:
            delta = closest
        elif(data_delta / closest) == 1:
            delta = closest / 10
        else:
            delta = closest
        start = self.__lo__lo - (self.__lo__lo % delta) + delta
        end = self.__hi__hi - (self.__hi__hi % delta)
 
        self.__delta__delta = delta
        self.__width__width = width
 
        # calculate text height
        max_text_height = ctx.text_extents("ABCDEFGHIJKLMNOPQRSTUVWXYZabcedefghijklmnopqrstuvwxyz0123456789")[3]
        self.max_text_heightmax_text_height = max_text_height
        height = max_text_height + 10
        self.__height__height = height
 
    def get_height(self):
        """! Get Height
        @param self: this object
        @return height
        """
        return self.__height__height
    def draw(self, ctx):
        """! Draw
        @param self this object
        @param ctx ctx
        @return none
        """
        delta = self.__delta__delta
        start = self.__lo__lo - (self.__lo__lo % delta) + delta
        end = self.__hi__hi - (self.__hi__hi % delta)
 
        if self.__top__top == 1:
            s = -1
        else:
            s = 1
        # print scale points
        ctx.set_source_rgb(0, 0, 0)
        ctx.set_line_width(1.0)
        ticks = range(int(start), int(end + delta), int(delta))
        for x in ticks:
            real_x = (x - self.__lo__lo ) * self.__width__width / (self.__hi__hi - self.__lo__lo)
            ctx.move_to(real_x, 0)
            ctx.line_to(real_x, 5*s)
            ctx.close_path()
            ctx.stroke()
            (t_y_bearing, t_width, t_height) = ctx.text_extents(str(x))[1:4]
            if self.__top__top:
                text_delta = t_height + t_y_bearing
            else:
                text_delta = -t_y_bearing
            ctx.move_to(real_x - t_width / 2, (5 + 5 + text_delta)*s)
            ctx.show_text(str(x))
        # draw subticks
        delta /= 10
        if delta > 0:
            start = self.__lo__lo - (self.__lo__lo % delta) + delta
            end = self.__hi__hi - (self.__hi__hi % delta)
            for x in range(int(start), int(end + delta), int(delta)):
                real_x = (x - self.__lo__lo ) * self.__width__width / (self.__hi__hi - self.__lo__lo)
                ctx.move_to(real_x, 0)
                ctx.line_to(real_x, 3*s)
                ctx.close_path()
                ctx.stroke()
 
 
 
class GraphicRenderer:
    
    def __init__(self, start, end):
        """! Initializer
        @param self this object
        @param start start
        @param end end
        @return none
        """
        self.__start__start = float(start)
        self.__end__end = float(end)
        self.__mid_scale__mid_scale = ScaleRenderer()
        self.__mid_scale__mid_scale.set_top()
        self.__bot_scale__bot_scale = ScaleRenderer()
        self.__bot_scale__bot_scale.set_bounds(start, end)
        self.__bot_scale__bot_scale.set_bot()
        self.__width__width = 1
        self.__height__height = 1
    def get_width(self):
        """! Get Width
        @param self: this object
        @return width
        """
        return self.__width__width
    def get_height(self):
        """! Get Height
        @param self this object
        @return height
        """
        return self.__height__height
    # return x, y, width, height
    def get_data_rectangle(self):
        """! Get Data Rectangle
        @param self this object
        @return rectangle
        """
        y_start = self.__top_legend__top_legend.get_height()
        x_start = self.__data__data.get_data_x_start()
        return(x_start, y_start, self.__width__width - x_start, self.__data__data.get_height())
    def scale_data(self, x):
        """! Get Data Rectangle
        @param self this object
        @param x x
        @return scaled x
        """
        x_start = self.__data__data.get_data_x_start()
        x_scaled = x / (self.__width__width - x_start) * (self.__r_end__r_end - self.__r_start__r_start)
        return x_scaled
    # return x, y, width, height
    def get_selection_rectangle(self):
        """! Get Selection Rectangle
        @param self this object
        @return rectangle
        """
        y_start = self.__top_legend__top_legend.get_height() + self.__data__data.get_height() + self.__mid_scale__mid_scale.get_height() + 20
        y_height = self.__bot_scale__bot_scale.get_height() + 20
        x_start = self.__bot_scale__bot_scale.get_position(self.__r_start__r_start)
        x_end = self.__bot_scale__bot_scale.get_position(self.__r_end__r_end)
        return(x_start, y_start, x_end - x_start, y_height)
    def scale_selection(self, x):
        """! Scale Selection
        @param self this object
        @param x the X
        @return scaled X
        """
        x_scaled = x / self.__width__width * (self.__end__end - self.__start__start)
        return x_scaled
    def set_range(self, start, end):
        """! Set Range
        @param self this object
        @param start start
        @param end end
        @return none
        """
        s = min(start, end)
        e = max(start, end)
        start = max(self.__start__start, s)
        end = min(self.__end__end, e)
        self.__r_start__r_start = start
        self.__r_end__r_end = end
        self.__data__data.set_render_range(start, end)
        self.__mid_scale__mid_scale.set_bounds(start, end)
        self.layoutlayout(self.__width__width, self.__height__height)
    def get_range(self):
        """! Get Range
        @param self this object
        @return range
        """
        return(self.__r_start__r_start, self.__r_end__r_end)
    def set_data(self, data):
        """! Set Date
        @param self this object
        @param data data
        @return none
        """
        self.__data__data = data
    def set_top_legend(self, top_legend):
        """! Set Top Legend
        @param self this object
        @param top_legend The legend
        @return none
        """
        self.__top_legend__top_legend = top_legend
    def layout(self, width, height):
        """! Set Layout
        @param self this object
        @param width width
        @param height height
        @return none
        """
        self.__width__width = width
        self.__height__height = height
        self.__top_legend__top_legend.layout(width)
        top_legend_height = self.__top_legend__top_legend.get_height()
        self.__data__data.layout(width)
        self.__mid_scale__mid_scale.layout(width - self.__data__data.get_data_x_start())
        self.__bot_scale__bot_scale.layout(width)
        return
    def __x_pixel(self, x, width):
        """! X Pixel
        @param self this object
        @param x x
        @param width width
        @return x pixel
        """
        new_x = (x - self.__start__start) * width / (self.__end__end - self.__start__start)
        return new_x
 
    def draw(self, ctx):
        """! Draw
        @param self this object
        @param ctx ctx
        @return none
        """
        # default background is white
        ctx.save()
        ctx.set_source_rgb(1, 1, 1)
        ctx.set_operator(cairo.OPERATOR_SOURCE)
        ctx.rectangle(0, 0, self.__width__width, self.__height__height)
        ctx.fill()
 
        # top legend
        ctx.save()
        self.__top_legend__top_legend.draw(ctx)
        top_legend_height = self.__top_legend__top_legend.get_height()
        ctx.restore()
 
        # separation line
        ctx.move_to(0, top_legend_height)
        ctx.line_to(self.__width__width, top_legend_height)
        ctx.close_path()
        ctx.set_line_width(2)
        ctx.set_source_rgb(0, 0, 0)
        ctx.stroke()
 
        # data
        ctx.save()
        ctx.translate(0,
                       top_legend_height)
        self.__data__data.draw(ctx)
        ctx.restore()
 
        # scale below data
        ctx.save()
        ctx.translate(self.__data__data.get_data_x_start(),
                       top_legend_height + self.__data__data.get_height() + self.__mid_scale__mid_scale.get_height())
        self.__mid_scale__mid_scale.draw(ctx)
        ctx.restore()
 
        height_used = top_legend_height + self.__data__data.get_height() + self.__mid_scale__mid_scale.get_height()
 
        # separation between scale and left pane
        ctx.move_to(self.__data__data.get_data_x_start(), height_used)
        ctx.rel_line_to(0, -self.__mid_scale__mid_scale.get_height())
        ctx.close_path()
        ctx.set_source_rgb(0, 0, 0)
        ctx.set_line_width(2)
        ctx.stroke()
 
        # separation below scale
        ctx.move_to(0, height_used)
        ctx.line_to(self.__width__width, height_used)
        ctx.close_path()
        ctx.set_line_width(2)
        ctx.set_source_rgb(0, 0, 0)
        ctx.stroke()
 
        select_start = self.__bot_scale__bot_scale.get_position(self.__r_start__r_start)
        select_end = self.__bot_scale__bot_scale.get_position(self.__r_end__r_end)
 
        # left connection between top scale and bottom scale
        ctx.move_to(0, height_used);
        ctx.line_to(self.__data__data.get_data_x_start(), height_used)
        ctx.line_to(select_start, height_used + 20)
        ctx.line_to(0, height_used + 20)
        ctx.line_to(0, height_used)
        ctx.set_source_rgb(0, 0, 0)
        ctx.set_line_width(1)
        ctx.stroke_preserve()
        ctx.set_source_rgb(0.9, 0.9, 0.9)
        ctx.fill()
 
        # right connection between top scale and bottom scale
        ctx.move_to(self.__width__width, height_used)
        ctx.line_to(self.__width__width, height_used + 20)
        ctx.line_to(select_end, height_used + 20)
        ctx.line_to(self.__width__width, height_used)
        ctx.set_source_rgb(0, 0, 0)
        ctx.set_line_width(1)
        ctx.stroke_preserve()
        ctx.set_source_rgb(0.9, 0.9, 0.9)
        ctx.fill()
 
        height_used += 20
 
        # unused area background
        unused_start = self.__bot_scale__bot_scale.get_position(self.__r_start__r_start)
        unused_end = self.__bot_scale__bot_scale.get_position(self.__r_end__r_end)
        unused_height = self.__bot_scale__bot_scale.get_height() + 20
        ctx.rectangle(0, height_used,
                       unused_start,
                       unused_height)
        ctx.rectangle(unused_end,
                       height_used,
                       self.__width__width - unused_end,
                       unused_height)
        ctx.set_source_rgb(0.9, 0.9, 0.9)
        ctx.fill()
 
        # border line around bottom scale
        ctx.move_to(unused_end, height_used)
        ctx.line_to(self.__width__width, height_used)
        ctx.line_to(self.__width__width, height_used + unused_height)
        ctx.line_to(0, height_used + unused_height)
        ctx.line_to(0, height_used)
        ctx.line_to(unused_start, height_used)
        ctx.close_path()
        ctx.set_line_width(2)
        ctx.set_source_rgb(0, 0, 0)
        ctx.stroke()
        ctx.move_to(unused_start, height_used)
        ctx.line_to(unused_end, height_used)
        ctx.close_path()
        ctx.set_line_width(1)
        ctx.set_source_rgb(0.9, 0.9, 0.9)
        ctx.stroke()
 
        # unused area dot borders
        ctx.save()
        ctx.move_to(max(unused_start, 2), height_used)
        ctx.rel_line_to(0, unused_height)
        ctx.move_to(min(unused_end, self.__width__width - 2), height_used)
        ctx.rel_line_to(0, unused_height)
        ctx.set_dash([5], 0)
        ctx.set_source_rgb(0, 0, 0)
        ctx.set_line_width(1)
        ctx.stroke()
        ctx.restore()
 
        # bottom scale
        ctx.save()
        ctx.translate(0, height_used)
        self.__bot_scale__bot_scale.draw(ctx)
        ctx.restore()
 
 
class GtkGraphicRenderer(gtk.DrawingArea):
    
    def __init__(self, data):
        """! Initializer
        @param self this object
        @param data data
        @return none
        """
        super(GtkGraphicRenderer, self).__init__()
        self.__data__data = data
        self.__moving_left__moving_left = False
        self.__moving_right__moving_right = False
        self.__moving_both__moving_both = False
        self.__moving_top__moving_top = False
        self.__force_full_redraw__force_full_redraw = True
        self.add_events(gtk.gdk.POINTER_MOTION_MASK)
        self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
        self.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
        self.connect("expose_event", self.exposeexpose)
        self.connect('size-allocate', self.size_allocatesize_allocate)
        self.connect('motion-notify-event', self.motion_notifymotion_notify)
        self.connect('button-press-event', self.button_pressbutton_press)
        self.connect('button-release-event', self.button_releasebutton_release)
    def set_smaller_zoom(self):
        """! Set Smaller Zoom
        @param self this object
        @return none
        """
        (start, end) = self.__data__data.get_range()
        self.__data__data.set_range(start, start + (end - start)*2)
        self.__force_full_redraw__force_full_redraw = True
        self.queue_draw()
    def set_bigger_zoom(self):
        """! Set Bigger Zoom
        @param self this object
        @return none
        """
        (start, end) = self.__data__data.get_range()
        self.__data__data.set_range(start, start + (end - start) / 2)
        self.__force_full_redraw__force_full_redraw = True
        self.queue_draw()
    def output_png(self, filename):
        """! Output PNG
        @param self this object
        @param filename file name
        @return none
        """
        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32,
                                     self.__data__data.get_width(),
                                     self.__data__data.get_height())
        ctx = cairo.Context(self.__buffer_surface__buffer_surface)
        self.__data__data.draw(ctx)
        surface.write_to_png(filename)
    def button_press(self, widget, event):
        """! Button Press
        @param self this object
        @param widget widget
        @param event event
        @return true if button has been pressed otherwise false
        """
        (x, y, width, height) = self.__data__data.get_selection_rectangle()
        (d_x, d_y, d_width, d_height) = self.__data__data.get_data_rectangle()
        if event.y > y and event.y < y + height:
            if abs(event.x - x) < 5:
                self.__moving_left__moving_left = True
                return True
            if abs(event.x - (x + width)) < 5:
                self.__moving_right__moving_right = True
                return True
            if event.x > x and event.x < x + width:
                self.__moving_both__moving_both = True
                self.__moving_both_start__moving_both_start = event.x
                self.__moving_both_cur__moving_both_cur = event.x
                return True
        if event.y > d_y and event.y < (d_y + d_height):
            if event.x > d_x and event.x < (d_x + d_width):
                self.__moving_top__moving_top = True
                self.__moving_top_start__moving_top_start = event.x
                self.__moving_top_cur__moving_top_cur = event.x
                return True
        return False
    def button_release(self, widget, event):
        """! Button Release
        @param self this object
        @param widget widget
        @param event event
        @return true if button was released otherwise false
        """
        if self.__moving_left__moving_left:
            self.__moving_left__moving_left = False
            left = self.__data__data.scale_selection(self.__moving_left_cur__moving_left_cur)
            right = self.__data__data.get_range()[1]
            self.__data__data.set_range(left, right)
            self.__force_full_redraw__force_full_redraw = True
            self.queue_draw()
            return True
        if self.__moving_right__moving_right:
            self.__moving_right__moving_right = False
            right = self.__data__data.scale_selection(self.__moving_right_cur__moving_right_cur)
            left = self.__data__data.get_range()[0]
            self.__data__data.set_range(left, right)
            self.__force_full_redraw__force_full_redraw = True
            self.queue_draw()
            return True
        if self.__moving_both__moving_both:
            self.__moving_both__moving_both = False
            delta = self.__data__data.scale_selection(self.__moving_both_cur__moving_both_cur - self.__moving_both_start__moving_both_start)
            (left, right) = self.__data__data.get_range()
            self.__data__data.set_range(left + delta, right + delta)
            self.__force_full_redraw__force_full_redraw = True
            self.queue_draw()
            return True
        if self.__moving_top__moving_top:
            self.__moving_top__moving_top = False
        return False
    def motion_notify(self, widget, event):
        """! Motion Notify
        @param self this object
        @param widget widget
        @param event event
        @return true if moving otherwise false
        """
        (x, y, width, height) = self.__data__data.get_selection_rectangle()
        if self.__moving_left__moving_left:
            if event.x <= 0:
                self.__moving_left_cur__moving_left_cur = 0
            elif event.x >= x + width:
                self.__moving_left_cur__moving_left_cur = x + width
            else:
                self.__moving_left_cur__moving_left_cur = event.x
            self.queue_draw_area(0, int(y), int(self.__width__width), int(height))
            return True
        if self.__moving_right__moving_right:
            if event.x >= self.__width__width:
                self.__moving_right__moving_right = self.__width__width
            elif event.x < x:
                self.__moving_right_cur__moving_right_cur = x
            else:
                self.__moving_right_cur__moving_right_cur = event.x
            self.queue_draw_area(0, int(y), int(self.__width__width), int(height))
            return True
        if self.__moving_both__moving_both:
            cur_e = self.__width__width - (x + width - self.__moving_both_start__moving_both_start)
            cur_s = (self.__moving_both_start__moving_both_start - x)
            if event.x < cur_s:
                self.__moving_both_cur__moving_both_cur = cur_s
            elif event.x > cur_e:
                self.__moving_both_cur__moving_both_cur = cur_e
            else:
                self.__moving_both_cur__moving_both_cur = event.x
            self.queue_draw_area(0, int(y), int(self.__width__width), int(height))
            return True
        if self.__moving_top__moving_top:
            self.__moving_top_cur__moving_top_cur = event.x
            delta = self.__data__data.scale_data(self.__moving_top_start__moving_top_start - self.__moving_top_cur__moving_top_cur)
            (left, right) = self.__data__data.get_range()
            self.__data__data.set_range(left + delta, right + delta)
            self.__force_full_redraw__force_full_redraw = True
            self.__moving_top_start__moving_top_start = event.x
            self.queue_draw()
            return True
        (d_x, d_y, d_width, d_height) = self.__data__data.get_data_rectangle()
        if event.y > y and event.y < y + height:
            if abs(event.x - x) < 5 or abs(event.x - (x + width)) < 5:
                widget.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.SB_H_DOUBLE_ARROW))
                return True
            if event.x > x and event.x < x + width:
                widget.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.FLEUR))
                return True
        if event.y > d_y and event.y < (d_y + d_height):
            if event.x > d_x and event.x < (d_x + d_width):
                widget.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.FLEUR))
                return True
        widget.window.set_cursor(None)
        return False
    def size_allocate(self, widget, allocation):
        """! Size Allocate
        @param self this object
        @param widget widget
        @param allocation allocation
        @return none
        """
        self.__width__width = allocation.width
        self.__height__height = allocation.height
        self.__data__data.layout(allocation.width, allocation.height)
        self.__force_full_redraw__force_full_redraw = True
        self.queue_draw()
    def expose(self, widget, event):
        """! Expose
        @param self this object
        @param widget widget
        @param event event
        @return false
        """
        if self.__force_full_redraw__force_full_redraw:
            self.__buffer_surface__buffer_surface = cairo.ImageSurface(cairo.FORMAT_ARGB32,
                                                       self.__data__data.get_width(),
                                                       self.__data__data.get_height())
            ctx = cairo.Context(self.__buffer_surface__buffer_surface)
            self.__data__data.draw(ctx)
            self.__force_full_redraw__force_full_redraw = False
        ctx = widget.window.cairo_create()
        ctx.rectangle(event.area.x, event.area.y,
                      event.area.width, event.area.height)
        ctx.clip()
        ctx.set_source_surface(self.__buffer_surface__buffer_surface)
        ctx.paint()
        (x, y, width, height) = self.__data__data.get_selection_rectangle()
        if self.__moving_left__moving_left:
            ctx.move_to(max(self.__moving_left_cur__moving_left_cur, 2), y)
            ctx.rel_line_to(0, height)
            ctx.close_path()
            ctx.set_line_width(1)
            ctx.set_source_rgb(0, 0, 0)
            ctx.stroke()
        if self.__moving_right__moving_right:
            ctx.move_to(min(self.__moving_right_cur__moving_right_cur, self.__width__width - 2), y)
            ctx.rel_line_to(0, height)
            ctx.close_path()
            ctx.set_line_width(1)
            ctx.set_source_rgb(0, 0, 0)
            ctx.stroke()
        if self.__moving_both__moving_both:
            delta_x = self.__moving_both_cur__moving_both_cur - self.__moving_both_start__moving_both_start
            left_x = x + delta_x
            ctx.move_to(x + delta_x, y)
            ctx.rel_line_to(0, height)
            ctx.close_path()
            ctx.move_to(x + width + delta_x, y)
            ctx.rel_line_to(0, height)
            ctx.close_path()
            ctx.set_source_rgb(0, 0, 0)
            ctx.set_line_width(1)
            ctx.stroke()
        return False
 
 
class MainWindow:
    
    def __init__(self):
        """! Initializer
        @param self this object
        @return none
        """
        return
    def run(self, graphic):
        """! Run function
        @param self this object
        @param graphic graphic
        @return none
        """
        window = gtk.Window()
        self.__window__window = window
        window.set_default_size(200, 200)
        vbox = gtk.VBox()
        window.add(vbox)
        render = GtkGraphicRenderer(graphic)
        self.__render__render = render
        vbox.pack_end(render, True, True, 0)
        hbox = gtk.HBox()
        vbox.pack_start(hbox, False, False, 0)
        smaller_zoom = gtk.Button("Zoom Out")
        smaller_zoom.connect("clicked", self.__set_smaller_cb__set_smaller_cb)
        hbox.pack_start(smaller_zoom)
        bigger_zoom = gtk.Button("Zoom In")
        bigger_zoom.connect("clicked", self.__set_bigger_cb__set_bigger_cb)
        hbox.pack_start(bigger_zoom)
        output_png = gtk.Button("Output Png")
        output_png.connect("clicked", self.__output_png_cb__output_png_cb)
        hbox.pack_start(output_png)
        window.connect('destroy', gtk.main_quit)
        window.show_all()
        #gtk.bindings_activate(gtk.main_quit, 'q', 0)
        gtk.main()
    def __set_smaller_cb(self, widget):
        """! Set Smaller Callback
        @param self this object
        @param widget widget
        @return none
        """
        self.__render__render.set_smaller_zoom()
    def __set_bigger_cb(self, widget):
        """! Set Bigger Callback
        @param self this object
        @param widget widget
        @return none
        """
        self.__render__render.set_bigger_zoom()
    def __output_png_cb(self, widget):
        """! Output PNG Callback
        @param self this object
        @param widget widget
        @return none
        """
        dialog = gtk.FileChooserDialog("Output Png", self.__window__window,
                                       gtk.FILE_CHOOSER_ACTION_SAVE, ("Save", 1))
        self.__dialog__dialog = dialog
        dialog.set_default_response(1)
        dialog.connect("response", self.__dialog_response_cb__dialog_response_cb)
        dialog.show()
        return
    def __dialog_response_cb(self, widget, response):
        """! Dialog Response Callback
        @param self this object
        @param widget widget
        @param response response
        @return none
        """
        if response == 1:
            filename = self.__dialog__dialog.get_filename()
            self.__render__render.output_png(filename)
            widget.hide()
        return
 
 
 
def read_data(filename):
    timelines = Timelines()
    colors = Colors()
    m1 = re.compile('range ([^ ]+) ([^ ]+) ([^ ]+) ([0-9]+) ([0-9]+)')
    m2 = re.compile('event-str ([^ ]+) ([^ ]+) ([^ ]+) ([0-9]+)')
    m3 = re.compile('event-int ([^ ]+) ([^ ]+) ([0-9]+) ([0-9]+)')
    m4 = re.compile('color ([^ ]+) #([a-fA-F0-9]{2,2})([a-fA-F0-9]{2,2})([a-fA-F0-9]{2,2})')
 
    with open(filename) as fh:
        for line in fh.readlines():
            m = m1.match(line)
            if m:
                line_name = m.group(1)
                timeline = timelines.get(m.group(1))
                rang = timeline.get_range(m.group(2))
                data_range = DataRange()
                data_range.value = m.group(3)
                data_range.start = int(m.group(4))
                data_range.end = int(m.group(5))
                rang.add_range(data_range)
                continue
            m = m2.match(line)
            if m:
                line_name = m.group(1)
                timeline = timelines.get(m.group(1))
                ev = timeline.get_event_str(m.group(2))
                event = EventString()
                event.value = m.group(3)
                event.at = int(m.group(4))
                ev.add_event(event)
                continue
            m = m3.match(line)
            if m:
                line_name = m.group(1)
                timeline = timelines.get(m.group(1))
                ev = timeline.get_event_int(m.group(2))
                event = EventInt()
                event.value = int(m.group(3))
                event.at = int(m.group(4))
                ev.add_event(event)
                continue
 
            m = m4.match(line)
            if m:
                r = int(m.group(2), 16)
                g = int(m.group(3), 16)
                b = int(m.group(4), 16)
                color = Color(r / 255, g / 255, b / 255)
                colors.add(m.group(1), color)
                continue
    timelines.sort()
    return (colors, timelines)
 
 
 
def main():
    (colors, timelines) = read_data(sys.argv[1])
    (lower_bound, upper_bound) = timelines.get_bounds()
    graphic = GraphicRenderer(lower_bound, upper_bound)
    top_legend = TopLegendRenderer()
    range_values = timelines.get_all_range_values()
    range_colors = []
    for range_value in range_values:
        range_colors.append(colors.lookup(range_value))
    top_legend.set_legends(range_values,
                           range_colors)
    graphic.set_top_legend(top_legend)
    data = TimelinesRenderer()
    data.set_timelines(timelines, colors)
    graphic.set_data(data)
 
    # default range
    range_mid = (upper_bound - lower_bound) / 2
    range_width = (upper_bound - lower_bound) / 10
    range_lo = range_mid - range_width / 2
    range_hi = range_mid + range_width / 2
    graphic.set_range(range_lo, range_hi)
 
    main_window = MainWindow()
    main_window.run(graphic)
 
 
main()