require 'Qt4'
require 'utilrb/module/attr_predicate'
require 'roby/distributed/protocol'
require 'roby/log/dot'
require 'roby/log/plan_rebuilder'
require 'roby/log/gui/relations_view'

module Roby
    class PlanObject::DRoby
	def display_parent; end
	def display_create(display); end
	def display_events; ValueSet.new end
	def display_name(display); remote_name end
	def display(display, graphics_item)
	end
    end

    module EventGeneratorDisplay
	def self.style(object, flags)
	    # This is for backward compatibility only. All events are now marshalled
	    # with their controllability.
	    if !object.controlable.nil?
		flags |= (object.controlable ? Log::EVENT_CONTROLABLE : Log::EVENT_CONTINGENT)
	    elsif (flags & Log::EVENT_CALLED) != 0
		flags |= Log::EVENT_CONTROLABLE
	    end

	    if !styles.has_key?(flags)
		raise ArgumentError, "event flags #{flags} have not style"
	    end

	    styles[flags]
	end

	def self.styles
	    if defined? @@event_styles
		return @@event_styles
	    end

	    @@event_styles = Hash.new
	    @@event_styles[Log::EVENT_CONTROLABLE | Log::EVENT_CALLED] =
		[Qt::Brush.new(Qt::Color.new(Log::PENDING_EVENT_COLOR)),
		    Qt::Pen.new(Qt::Color.new(Log::PENDING_EVENT_COLOR))]
	    @@event_styles[Log::EVENT_CONTROLABLE | Log::EVENT_EMITTED] =
		[Qt::Brush.new(Qt::Color.new(Log::FIRED_EVENT_COLOR)),
		    Qt::Pen.new(Qt::Color.new(Log::FIRED_EVENT_COLOR))]
	    @@event_styles[Log::EVENT_CONTROLABLE | Log::EVENT_CALLED_AND_EMITTED] =
		[Qt::Brush.new(Qt::Color.new(Log::FIRED_EVENT_COLOR)),
		    Qt::Pen.new(Qt::Color.new(Log::PENDING_EVENT_COLOR))]
	    @@event_styles[Log::EVENT_CONTINGENT | Log::EVENT_EMITTED] =
		[Qt::Brush.new(Qt::Color.new('white')), Qt::Pen.new(Qt::Color.new(Log::FIRED_EVENT_COLOR))]
	    @@event_styles
	end

	def self.priorities
	    @@priorities ||= Hash.new
	end

	def display_create(display)
	    scene = display.scene
	    circle = scene.add_ellipse(-Log::EVENT_CIRCLE_RADIUS, -Log::EVENT_CIRCLE_RADIUS, Log::EVENT_CIRCLE_RADIUS * 2, Log::EVENT_CIRCLE_RADIUS * 2)
	    text   = scene.add_text(display_name(display))
	    circle.singleton_class.class_eval { attr_accessor :text }
	    circle.z_value = Log::EVENT_LAYER

	    text.parent_item = circle
	    text_width   = text.bounding_rect.width
	    text.set_pos(-text_width / 2, 0)
	    circle.text = text
	    circle
	end

	def display_time_start(circle, pos); circle.translate(pos) end
	def display_time_end(circle, pos); end
    end

    class EventGenerator::DRoby
	include EventGeneratorDisplay

	def display_name(display)
	    name = if model.ancestors[0][0] != 'Roby::EventGenerator'
		       [display.filter_prefixes(model.ancestors[0][0].dup)]
		   else
		       []
		   end

	    if display.show_ownership
		name << owners_to_s
	    end
	    name.join("\n")
	end

	def display(display, graphics_item)
	    graphics_item.text.plain_text = display_name(display).to_s
	end
    end

    class TaskEventGenerator::DRoby
	include EventGeneratorDisplay
	def display_parent; task end
	def display_name(display); symbol.to_s end

	def display(display, graphics_item)
	end
    end

    module LoggedTask
	def layout_events(display)
	    graphics_item = display[self]

	    width, height = 0, 0
	    events = self.events.map do |_, e| 
		next unless display.displayed?(e)
		next unless circle = display[e]
		br = (circle.bounding_rect | circle.children_bounding_rect)
		[e, circle, br]
	    end
	    events.compact!
	    events = events.sort_by { |ev, _| EventGeneratorDisplay.priorities[ev] }

	    events.each do |_, circle, br|
		w, h = br.width, br.height
		height = h if h > height
		width += w
	    end
	    width  += Log::TASK_EVENT_SPACING * (events.size + 1)
	    height += Log::TASK_EVENT_SPACING

	    x = -width  / 2 + Log::TASK_EVENT_SPACING
	    events.each do |e, circle, br|
		w  = br.width
		circle.set_pos(x + w / 2, -br.height / 2 + Log::EVENT_CIRCLE_RADIUS + Log::TASK_EVENT_SPACING)
		x += w + Log::TASK_EVENT_SPACING
	    end

	    width = Log::DEFAULT_TASK_WIDTH unless width > Log::DEFAULT_TASK_WIDTH
	    height = Log::DEFAULT_TASK_HEIGHT unless height > Log::DEFAULT_TASK_HEIGHT

	    if @width != width || @height != height
		@width, @height = width, height
		coords = Qt::RectF.new -(width / 2), -(height / 2), width, height
		graphics_item.rect = coords
	    end

	    text = graphics_item.text
	    text.set_pos(- text.bounding_rect.width / 2, height / 2 + Log::TASK_EVENT_SPACING)
	end

	def display_create(display)
	    scene = display.scene
	    rect = scene.add_rect Qt::RectF.new(0, 0, 0, 0)
	    text = scene.add_text display_name(display)
	    rect.brush = Qt::Brush.new(Log::TASK_BRUSH_COLORS[:pending])
	    rect.pen   = Qt::Pen.new(Log::TASK_PEN_COLORS[:pending])
	    @displayed_state = :pending
	    text.parent_item = rect
	    rect.singleton_class.class_eval { attr_accessor :text }
	    rect.text = text
	    rect.z_value = Log::TASK_LAYER

	    rect.set_data(0, Qt::Variant.new(self.object_id.to_s))
	    rect
	end

	def display_time_start(rect, pos); rect.left = pos end
	def display_time_end(rect, pos);   rect.right = pos end
    end

    class Task::DRoby
	include LoggedTask
	attr_accessor :last_event

	def display_name(display)
	    name = display.filter_prefixes(model.ancestors[0][0].dup)
	    if display.show_ownership
		name << "\n#{owners_to_s}"
	    end
	    name
	end

	def current_state
	    new_state = if plan && plan.finalized_tasks.include?(self)
			    :finalized
			else
			    [:success, :finished, :started, :pending].
				find { |flag| flags[flag] } 
			end
	    new_state || :pending
	end

	attr_reader :displayed_state
	def update_graphics(display, graphics_item)
	    new_state = current_state
	    if displayed_state != new_state
		graphics_item.brush = Qt::Brush.new(Log::TASK_BRUSH_COLORS[new_state])
		graphics_item.pen   = Qt::Pen.new(Log::TASK_PEN_COLORS[new_state])
		displayed_state = new_state
	    end

	    graphics_item.text.plain_text = display_name(display).to_s

	end

	def display(display, graphics_item)
	    update_graphics(display, graphics_item)
	    super
	    layout_events(display)
	end
    end

    class Transaction::Proxy::DRoby
	include LoggedTask

	attr_writer :real_object
	def flags; real_object.flags end

	def display_parent; end
	def display_name(display); real_object.display_name(display) end
	def display_create(display)
	    scene = display.scene
	    item = super

	    brush = item.brush
	    brush.style = Qt::BDiagPattern
	    item.brush = brush
	    item
	end
	def display(display, graphics_item)
	    graphics_item.text.plain_text = display_name(display).to_s
	    layout_events(display)
	end
    end

    module LoggedPlan
	PLAN_STROKE_WIDTH = 5
	# The plan depth, i.e. its distance from the root plan
	attr_reader :depth
	# The max depth of the plan tree in this branch
	attr_reader :max_depth

	def display_create(display)
	    scene = display.scene
	    pen            = Qt::Pen.new
	    pen.width      = PLAN_STROKE_WIDTH
	    pen.style      = Qt::SolidLine
	    pen.cap_style  = Qt::SquareCap
	    pen.join_style = Qt::RoundJoin
	    scene.add_rect Qt::RectF.new(0, 0, 0, 0), pen
	end
	def display_parent; parent_plan end
	def display(display, item)
	    #STDERR.puts "DISPLAYING PLAN\n  #{caller.join("\n  ")}"
	end
    end

    module Log
	EVENT_CIRCLE_RADIUS = 3
	TASK_EVENT_SPACING  = 5
	DEFAULT_TASK_WIDTH = 20
	DEFAULT_TASK_HEIGHT = 10
	ARROW_COLOR   = Qt::Color.new('black')
	ARROW_OPENING = 30
	ARROW_SIZE    = 10

	PROPAG_SIGNAL   = 1
	PROPAG_FORWARD  = 2
	PROPAG_CALLING  = 3
	PROPAG_EMITTING = 4

	EVENT_CONTINGENT  = 0
	EVENT_CONTROLABLE = 1
	EVENT_CALLED      = 2
	EVENT_EMITTED     = 4
	EVENT_CALLED_AND_EMITTED = EVENT_CALLED | EVENT_EMITTED

	TASK_BRUSH_COLORS = {
	    :pending  => Qt::Color.new('#6DF3FF'),
	    :started  => Qt::Color.new('#B0FFA6'),
	    :success  => Qt::Color.new('#E2E2E2'),
	    :finished => Qt::Color.new('#E2A8A8'),
	    :finalized => Qt::Color.new('#555555')
	}
	TASK_PEN_COLORS = {
	    :pending  => Qt::Color.new('#6DF3FF'),
	    :started  => Qt::Color.new('#B0FFA6'),
	    :success  => Qt::Color.new('#E2E2E2'),
	    :finished => Qt::Color.new('#E2A8A8'),
	    :finalized => Qt::Color.new('#555555')
	}
	TASK_NAME_COLOR = 'black'
	TASK_FONTSIZE = 10

	PENDING_EVENT_COLOR    = 'black' # default color for events
	FIRED_EVENT_COLOR      = 'red'
	EVENT_FONTSIZE = 8

	PLAN_LAYER             = 0
	TASK_LAYER	       = PLAN_LAYER + 20
	EVENT_LAYER	       = PLAN_LAYER + 30

	FIND_MARGIN = 10

	class Qt::GraphicsScene
	    attr_reader :default_arrow_pen
	    attr_reader :default_arrow_brush
	    def add_arrow(size, pen = nil, brush = nil)
		@default_arrow_pen   ||= Qt::Pen.new(ARROW_COLOR)
		@default_arrow_brush ||= Qt::Brush.new(ARROW_COLOR)

		@arrow_points ||= (1..4).map { Qt::PointF.new(0, 0) }
		@arrow_points[1].x = -size
		@arrow_points[1].y = size / 2
		@arrow_points[2].x = -size
		@arrow_points[2].y = -size / 2
		polygon = Qt::PolygonF.new(@arrow_points)
		@arrow_line ||=   Qt::LineF.new(-1, 0, 0, 0)

		ending = add_polygon polygon, (pen || default_arrow_pen), (brush || default_arrow_brush)
		line   = add_line @arrow_line

		line.parent_item = ending
		ending.singleton_class.class_eval { attr_accessor :line }
		ending.line = line
		ending
	    end
	end

	def self.intersect_rect(w, h, from, to)
	    to_x, to_y = *to
	    from_x, from_y = *from

	    # We only use half dimensions since 'to' is supposed to be be the
	    # center of the rectangle we are intersecting
	    w /= 2
	    h /= 2

	    dx    = (to_x - from_x)
	    dy    = (to_y - from_y)
	    delta_x = dx / dy * h
	    if dy != 0 && delta_x.abs < w
		if dy > 0
		    [to_x - delta_x, to_y - h]
		else
		    [to_x + delta_x, to_y + h]
		end
	    elsif dx != 0
		delta_y = dy / dx * w
		if dx > 0
		    [to_x - w, to_y - delta_y]
		else
		    [to_x + w, to_y + delta_y]
		end
	    else
		[0, 0]
	    end
	end
	
	def self.correct_line(from, to, rect)
	    intersect_rect(rect.width, rect.height, from, to)
	end

	def self.arrow_set(arrow, start_object, end_object)
	    start_br    = start_object.scene_bounding_rect
	    end_br      = end_object.scene_bounding_rect
	    start_point = start_br.center
	    end_point   = end_br.center

	    #from = intersect_rect(start_br.width, start_br.height, end_point, start_point)
	    from = [start_point.x, start_point.y]
	    to   = intersect_rect(end_br.width, end_br.height, from, [end_point.x, end_point.y])

	    dy = to[1] - from[1]
	    dx = to[0] - from[0]
	    alpha  = Math.atan2(dy, dx)
	    length = Math.sqrt(dx ** 2 + dy ** 2)

	    #arrow.line.set_line from[0], from[1], to[0], to[1]
	    arrow.resetMatrix
	    arrow.line.set_line(-length, 0, 0, 0)
	    arrow.translate to[0], to[1]
	    arrow.rotate(alpha * 180 / Math::PI)
	end

	module TaskDisplaySupport
	    # A regex => boolean map of prefixes that should be removed from
	    # the task names
	    attribute :removed_prefixes do
		{ "Roby::" => false, 
		    "Roby::Genom::" => false }
	    end

	    # Compute the prefixes to remove from in filter_prefixes:
	    # enable only the ones that are flagged, and sort them by
	    # prefix length
	    def update_prefixes_removal
		@prefixes_removal = removed_prefixes.find_all { |p, b| b }.
		    map { |p, b| p }.
		    sort_by { |p| p.length }.
		    reverse
	    end

	    def filter_prefixes(string)
		# @prefixes_removal is computed in RelationsDisplay#update
		for prefix in @prefixes_removal
		    string = string.gsub(prefix, '')
		end
		string
	    end

	    # If true, show the ownership in the task descriptions
	    attribute(:show_ownership) { true }
	    # If true, show the arguments in the task descriptions
	    attribute(:show_arguments) { false }
	end

	class RelationsDisplay < Qt::Object
	    include DataDisplay
	    decoder PlanRebuilder

	    include TaskDisplaySupport

	    attr_reader :ui, :scene

	    # A [DRbObject, DRbObject] => GraphicsItem mapping of arrows
	    attr_reader :arrows

	    # A DRbObject => GraphicsItem mapping
	    attr_reader :graphics

	    # The set of objects that are to be shown permanently
	    attr_reader :visible_objects

	    # A set of events that are shown during only two calls of #update
	    attr_reader :flashing_objects

	    # The set of signals since the last call to #update
	    # Each element is [flag, from, to, event_id]
	    attr_reader :propagated_events

	    # The array of events for which a command has been called, or which
	    # have been emitted. The order in this array is the arrival order
	    # of the corresponding events.
	    #
	    # An array element is [fired, event], when fired is true if the
	    # event has been fired, and false if it is pending
	    attr_reader :execution_events

	    # The set of postponed events that have occured since the last call
	    # to #update. Each element is [postponed_generator,
	    # until_generator]
	    attr_reader :postponed_events

	    # A pool of arrows items used to display the event signalling
	    attr_reader :signal_arrows

	    # True if the finalized tasks should not be displayed
	    attr_accessor :hide_finalized

	    def initialize
		@scene  = Qt::GraphicsScene.new
		super()

		@main   = Qt::MainWindow.new
		@ui     = Ui::RelationsView.new

		@graphics          = Hash.new
		@visible_objects   = ValueSet.new
		@flashing_objects  = Hash.new
		@arrows            = Hash.new
		@enabled_relations = Set.new
		@layout_relations  = Set.new
		@relation_colors   = Hash.new
		@relation_pens     = Hash.new(Qt::Pen.new(Qt::Color.new(ARROW_COLOR)))
		@relation_brushes  = Hash.new(Qt::Brush.new(Qt::Color.new(ARROW_COLOR)))
		@current_color     = 0

		@propagated_events  = []
		@execution_events  = []
		@postponed_events  = ValueSet.new
		@signal_arrows     = []
		@hide_finalized	   = true

		ui.setupUi(self)
		ui.graphics.scene = scene

		default_colors = {
		    Roby::TaskStructure::Hierarchy => 'grey',
		    Roby::TaskStructure::PlannedBy => '#32ba21',
		    Roby::TaskStructure::ExecutionAgent => '#5d95cf',
		    Roby::TaskStructure::ErrorHandling => '#ff2727'
		}
		default_colors.each do |rel, color|
		    update_relation_color(rel, color)
		end

		@shortcuts = []
		shortcut = Qt::Shortcut.new(Qt::KeySequence.new('f'), main)
		connect(shortcut, SIGNAL('activated()'), self, SLOT('find()'))
		@shortcuts << shortcut
		main.resize 500, 500
	    end

	    def object_of(item)
		return if !(id = item.data(0).to_int).valid?
		id = id.to_int

		obj, _ = graphics.find do |obj, obj_item| 
		    obj.object_id == id
		end
		obj
	    end

	    def stream=(data_stream)
		super

		# Initialize the display ...
		decoder.plans.each do |plan|
		    discovered_tasks(Time.now, plan, plan.known_tasks)
		    discovered_events(Time.now, plan, plan.free_events)
		end
		display
	    end

	    def [](item); graphics[item] end
	    def task_relation(from, to, rel, info)
		arrow(from, to, rel, info, TASK_LAYER)
	    end
	    def event_relation(form, to, rel, info)
		arrow(from, to, rel, info, EVENT_LAYER)
	    end

	    def arrow(from, to, rel, info, base_layer)
		id = [from, to, rel]
		unless item = arrows[id]
		    item = (arrows[id] ||= scene.add_arrow(ARROW_SIZE))
		    item.z_value      = base_layer - 1
		    item.pen   = item.line.pen = relation_pens[rel]
		    item.brush = relation_brushes[rel]
		end
		Log.arrow_set item, self[from], self[to]
	    end

	    # Centers the view on the set of object found which matches
	    # +regex+.  If +regex+ is nil, ask one to the user
	    def find(regex = nil)
		unless regex
		    regex = Qt::InputDialog.get_text main, 'Find objects in relation view', 'Object name'
		    return unless regex && !regex.empty?
		end
		regex = /#{regex.to_str}/i if regex.respond_to?(:to_str)

		# Get the tasks and events matching the string
		objects = []
		for p in decoder.plans
		    objects.concat p.known_tasks.
			find_all { |object| displayed?(object) && regex === object.display_name(self) }
		    objects.concat p.free_events.
			find_all { |object| displayed?(object) && regex === object.display_name(self) }
		end

		return if objects.empty?

		# Find the graphics items
		bb = objects.inject(Qt::RectF.new) do |bb, object| 
		    if item = self[object]
			item.selected = true
			bb | item.scene_bounding_rect | item.map_to_scene(item.children_bounding_rect).bounding_rect
		    else
			bb
		    end
		end
		bb.adjust -FIND_MARGIN, -FIND_MARGIN, FIND_MARGIN, FIND_MARGIN
		ui.graphics.fit_in_view bb, Qt::KeepAspectRatio
		scale = ui.graphics.matrix.m11
		if scale > 1
		    ui.graphics.resetMatrix
		    ui.graphics.scale 1, 1
		end
	    end
	    slots 'find()'

	    attr_accessor :keep_signals

	    COLORS = %w{'black' #800000 #008000 #000080 #C05800 #6633FF #CDBE70 #CD8162 #A2B5CD}
	    attr_reader :current_color
	    # returns the next color in COLORS, cycles if at the end of the array
	    def allocate_color
		@current_color = (current_color + 1) % COLORS.size
		COLORS[current_color]
	    end

	    def relation_enabled?(relation); @enabled_relations.include?(relation) end
	    def layout_relation?(relation); relation_enabled?(relation) || @layout_relations.include?(relation) end

	    def enable_relation(relation)
		return if relation_enabled?(relation)
		@enabled_relations << relation
		arrows.each do |(_, _, rel), arrow|
		    if rel == relation
			arrow.visible = true 
		    end
		end
	    end

	    attr_reader :enabled_relations
	    def layout_relation(relation)
		disable_relation(relation)
		@layout_relations << relation
	    end
	    def ignore_relation(relation)
		disable_relation(relation)
		@layout_relations.delete(relation)
	    end

	    def disable_relation(relation)
		return unless relation_enabled?(relation)
		@enabled_relations.delete(relation)
		arrows.each do |(_, _, rel), arrow|
		    if rel == relation
			arrow.visible = false 
		    end
		end
	    end

	    attr_reader :relation_colors
	    attr_reader :relation_pens
	    attr_reader :relation_brushes
	    def relation_color(relation)
		if !relation_colors.has_key?(relation)
		    update_relation_color(relation, allocate_color)
		end
		relation_colors[relation]
	    end
	    def update_relation_color(relation, color)
		relation_colors[relation] = color
		color = Qt::Color.new(color)
		pen   = relation_pens[relation]    = Qt::Pen.new(color)
		brush = relation_brushes[relation] = Qt::Brush.new(color)
		arrows.each do |(_, _, rel), arrow|
		    if rel == relation
			arrow.pen = arrow.line.pen = pen
			arrow.brush = brush
		    end
		end
	    end

	    def layout_method=(new_method)
		return if new_method == @layout_method

		@layout_method  = nil
		@layout_options = nil
		if new_method
		    new_method =~ /^(\w+)(?: \[(.*)\])?$/
		    @layout_method    = $1
		    if $2
			@layout_options = $2.split(",").inject(Hash.new) do |h, v|
			    k, v = v.split("=")
			    h[k] = v
			    h
			end
		    end
		end
		display
	    end
	    def layout_options
		return @layout_options if @layout_options
		{ :rankdir => 'TB' }
	    end
	    def layout_method
		return @layout_method if @layout_method
		"dot"
	    end

	    def displayed?(object)
	       	visible_objects.include?(object) || 
		    flashing_objects.has_key?(object) 
	    end
	    def set_visibility(object, flag)
		return if visible_objects.include?(object) == flag

		if item = graphics[object]
		    item.visible = flag
		end

		if flag
		    visible_objects << object
		else
		    visible_objects.delete(object)
		end
	    end

	    def create_or_get_item(object)
		unless item = graphics[object]
		    item = graphics[object] = object.display_create(self)
		    if item
			item.parent_item = self[object.display_parent] if object.display_parent
			yield(item) if block_given?

			if !displayed?(object) 
			    item.visible = false
			end
		    end
		end

		item.visible = displayed?(object)
		item
	    end

	    # Add +object+ to the list of objects temporarily displayed. If a
	    # block is given, the object is removed when the block returns
	    # false. Otherwise, it is removed at the next display update
	    #
	    # If this method is called more than once for the same object, the
	    # object is removed when *all* blocks have returned false at least
	    # once
	    def add_flashing_object(object, &block)
		if block
		    flashing_objects[object] ||= []
		    flashing_objects[object] << block
		else
		    flashing_objects[object] ||= nil
		end

		create_or_get_item(object)
	    end
	    def clear_flashing_objects
		(flashing_objects.keys.to_value_set - visible_objects).each do |object|
		    if blocks = flashing_objects[object]
			blocks.delete_if { |block| !block.call }
			next unless blocks.empty?
		    end

		    if item = graphics[object]
			item.visible = false
		    end
		    flashing_objects.delete(object)
		end
	    end

	    def propagation_style(arrow, flag)
		unless defined? @@propagation_styles
		    @@propagation_styles = Hash.new
		    @@propagation_styles[PROPAG_FORWARD] = 
			[Qt::Brush.new(Qt::Color.new('black')), (forward_pen = Qt::Pen.new)]
		    forward_pen.style = Qt::DotLine
		    @@propagation_styles[PROPAG_SIGNAL] = 
			[Qt::Brush.new(Qt::Color.new('black')), Qt::Pen.new]
		    @@propagation_styles[PROPAG_EMITTING] = 
			[Qt::Brush.new(Qt::Color.new('blue')), (emitting_pen = Qt::Pen.new(Qt::Color.new('blue')))]
		    emitting_pen.style = Qt::DotLine
		    @@propagation_styles[PROPAG_CALLING] = 
			[Qt::Brush.new(Qt::Color.new('blue')), Qt::Pen.new(Qt::Color.new('blue'))]
		end
		arrow.brush, pen = @@propagation_styles[flag]
		arrow.pen = arrow.line.pen = pen
	    end

	    def clear_integrated
		postponed_events.clear
		execution_events.clear
		@execution_events = execution_events.find_all { |fired, ev| !fired }
	    end

	    def update
		return unless decoder

		if keep_signals
		    @execution_events = @last_execution_events.concat(execution_events)
		    @propagated_events.concat @last_propagated_events
		end

		update_prefixes_removal
		clear_flashing_objects

		# The sets of tasks and events know to the data stream
		all_tasks  = decoder.plans.inject(ValueSet.new) do |all_tasks, plan|
		    all_tasks.merge plan.known_tasks
		    all_tasks.merge plan.finalized_tasks
		end
		all_events = decoder.plans.inject(ValueSet.new) do |all_events, plan|
		    all_events.merge plan.free_events
		    all_events.merge plan.finalized_events
		end

		# Remove the items for objects that don't exist anymore
		(graphics.keys.to_value_set - all_tasks - all_events).each do |obj|
		    visible_objects.delete(obj)
		    remove_graphics(graphics.delete(obj))
		    clear_arrows(obj)
		end

		visible_objects.merge(decoder.plans)

		decoder.plans.each do |plan|
		    if hide_finalized
			@visible_objects = visible_objects - plan.finalized_tasks
			@visible_objects = visible_objects - plan.finalized_events

			all_finalized = plan.finalized_tasks | plan.finalized_events
			flashing_objects.delete_if { |obj, _| all_finalized.include?(obj) }
		    else
			visible_objects.merge(plan.finalized_tasks)
			visible_objects.merge(plan.finalized_events)
		    end
		end

		# Create graphics items for tasks and events if necessary, and
		# update their visibility according to the visible_objects set
		[all_tasks, all_events, decoder.plans].each do |object_set|
		    object_set.each do |object|
			if displayed?(object)
			    create_or_get_item(object)
			elsif !object.display_parent
			    if item = graphics[object]
				item.visible = false
			    end
			end
		    end
		end

		EventGeneratorDisplay.priorities.clear
		event_priority = 0
		execution_events.each_with_index do |(flags, object), event_priority|
		    EventGeneratorDisplay.priorities[object] = event_priority
		    next if object.respond_to?(:task) && !displayed?(object.task)

		    graphics = if flashing_objects.has_key?(object)
				   self.graphics[object]
			       else
				   add_flashing_object(object)
			       end

		    graphics.brush, graphics.pen = EventGeneratorDisplay.style(object, flags)
		end
		
		propagated_events.each do |_, sources, to, _|
		    sources.each do |from|
			if !EventGeneratorDisplay.priorities.has_key?(from)
			    EventGeneratorDisplay.priorities[from] = (event_priority += 1)
			end
			if !EventGeneratorDisplay.priorities.has_key?(to)
			    EventGeneratorDisplay.priorities[to] = (event_priority += 1)
			end

			if from.respond_to?(:task) 
			    next if !displayed?(from.task)
			else
			    next if !all_events.include?(from)
			end
			if to.respond_to?(:task) 
			    next if !displayed?(to.task)
			else
			    next if !all_events.include?(to)
			end

			add_flashing_object from
			add_flashing_object to
		    end
		end


		[all_tasks, all_events, decoder.plans].each do |object_set|
		    object_set.each do |object|
			next unless displayed?(object)
			object.display(self, graphics[object])
		    end
		end

		# Update arrow visibility
		arrows.each do |(from, to, rel), item|
		    item.visible = (displayed?(from) && displayed?(to))
		end

		# Layout the graph
		layouts = decoder.plans.find_all { |p| p.root_plan? }.
		    map do |p| 
			dot = Layout.new
			dot.layout(self, p)
			dot
		    end
		layouts.each { |dot| dot.apply }

		# Display the signals
		signal_arrow_idx = -1
		propagated_events.each_with_index do |(flag, sources, to), signal_arrow_idx|
		    sources.each do |from|
			unless arrow = signal_arrows[signal_arrow_idx]
			    arrow = signal_arrows[signal_arrow_idx] = scene.add_arrow(ARROW_SIZE)
			    arrow.z_value      = EVENT_LAYER + 1
			    arrow.line.z_value = EVENT_LAYER - 1
			end

			# It is possible that the objects have been removed in the
			# same display cycle than they have been signalled. Do not
			# display them if it is the case
			unless displayed?(from) && displayed?(to)
			    arrow.visible = false
			    next
			end
			puts from if !self[from]
			puts to   if !self[to]

			arrow.visible = true
			propagation_style(arrow, flag)
			Log.arrow_set(arrow, self[from], self[to])
		    end
		end
		# ... and hide the remaining arrows that are not used anymore
		if signal_arrow_idx + 1 < signal_arrows.size
		    signal_arrows[(signal_arrow_idx + 1)..-1].each do |arrow| 
			arrow.visible = false 
		    end
		end

		@last_propagated_events, @propagated_events = propagated_events, Array.new
		@last_execution_events, @execution_events = 
		    execution_events.partition { |fired, ev| fired }

		postponed_events.clear
	    end

	    def remove_graphics(item, scene = nil)
		return unless item
		scene ||= item.scene
		scene.remove_item(item) if scene
	    end

	    def local_task(obj); decoder.local_task(obj) end
	    def local_event(obj); decoder.local_event(obj) end
	    def local_plan(obj); decoder.local_plan(obj) end
	    def local_object(obj); decoder.local_object(obj) end

	    def add_internal_propagation(flag, generator, source_generators)
		generator = local_event(generator)
		if source_generators && !source_generators.empty?
		    source_generators = source_generators.map { |source_generator| local_event(source_generator) }
		    source_generators.delete_if do |ev|
			ev == generator ||
			    propagated_events.find { |_, from, to| to == generator && from.include?(ev) }
		    end
		    unless source_generators.empty?
			propagated_events << [flag, source_generators, generator]
		    end
		end
	    end
	    def generator_calling(*args)
		if args.size == 3
		    time, generator, context = *args
		    source_generators = []
		else
		    time, generator, source_generators, context = *args
		end

		add_internal_propagation(PROPAG_CALLING, generator, source_generators)
	    end
	    def generator_emitting(*args)
		if args.size == 3
		    time, generator, context = *args
		    source_generators = []
		else
		    time, generator, source_generators, context = *args
		end

		add_internal_propagation(PROPAG_EMITTING, generator, source_generators)
	    end
	    def generator_signalling(time, flag, from, to, event_id, event_time, event_context)
		propagated_events << [PROPAG_SIGNAL, [local_event(from)], local_event(to)]
	    end
	    def generator_forwarding(time, flag, from, to, event_id, event_time, event_context)
		propagated_events << [PROPAG_FORWARD, [local_event(from)], local_event(to)]
	    end

	    def generator_called(time, generator, context)
		execution_events << [EVENT_CALLED, local_event(generator)]
	    end
	    def generator_fired(time, generator, event_id, event_time, event_context)
		generator = local_event(generator)

		found_pending = false
		execution_events.delete_if do |flags, ev| 
		    if flags == EVENT_CALLED && generator == ev
			found_pending = true
		    end
		end
		execution_events << [(found_pending ? EVENT_CALLED_AND_EMITTED : EVENT_EMITTED), generator]
	    end
	    def generator_postponed(time, generator, context, until_generator, reason)
		postponed_events << [local_event(generator), local_event(until_generator)]
	    end


	    def removed_task_child(time, parent, rel, child)
		remove_graphics(arrows.delete([local_task(parent), local_task(child), rel]))
	    end
	    def removed_event_child(time, parent, rel, child)
		remove_graphics(arrows.delete([local_event(parent), local_event(child), rel]))
	    end
	    def discovered_tasks(time, plan, tasks)
		tasks.each do |obj| 
		    obj.flags[:pending] = true if obj.respond_to?(:flags)
		    task = local_task(obj)

		    set_visibility(task, true)
		    task.events.each_value do |ev|
			if item = self[ev]
			    item.visible = false
			end
		    end
		end
	    end
	    def clear_arrows(object)
		arrows.delete_if do |(from, to, _), arrow|
		    if from == object || to == object
			remove_graphics(arrow)
			true
		    end
		end
	    end

	    def clear
		arrows.dup.each_value(&method(:remove_graphics))
		graphics.dup.each_value(&method(:remove_graphics))
		arrows.clear
		graphics.clear

		signal_arrows.each do |arrow|
		    arrow.visible = false
		end

		visible_objects.clear
		flashing_objects.clear
		propagated_events.clear
		execution_events.clear
		postponed_events.clear

		scene.update(scene.scene_rect)
	    end
	end
    end
end


if $0 == __FILE__
    require 'roby/log/file'
    include Roby::Log
    app     = Qt::Application.new(ARGV)
    builder = PlanRebuild.new
    rel     = RelationsDisplay.new(builder)
    rel.main_widget.show
    Roby::Log.replay(ARGV[0]) do |method_name, method_args|
	builder.send(method_name, *method_args) if builder.respond_to?(method_name)
	rel.send(method_name, *method_args) if rel.respond_to?(method_name)
    end
    app.exec
end