roby 0.8.0 → 3.0.0

data/lib/roby/gui/plan_rebuilder_widget.rb

@@ -0,0 +1,357 @@
+require 'roby/gui/qt4_toMSecsSinceEpoch'
+require 'roby/droby/plan_rebuilder'
+require 'roby/gui/stepping'
+
+module Roby
+    module GUI
+        # This widget displays information about the event history in a list,
+        # allowing to switch between the "important events" in this history
+        class PlanRebuilderWidget < Qt::Widget
+            # The list used to display all the cycles in the history
+            attr_reader :list
+            # The history, as a mapping from the cycle index to a (time,
+            # snapshot, list_item) triple
+            attr_reader :history
+            # The PlanRebuilder object we use to process the log data
+            attr_reader :plan_rebuilder
+            # The current plan managed by the widget
+            attr_reader :current_plan
+            # The underlying log file
+            # @return [DRoby::Logfile::Reader]
+            attr_reader :logfile
+            # The last processed cycle
+            # @return [Integer]
+            attr_reader :last_cycle
+
+            # Signal emitted when an informational message is meant to be
+            # displayed
+            signals 'info(QString)'
+            # Signal emitted when a warning message is meant to be displayed
+            signals 'warn(QString)'
+            # Signal emitted when the currently displayed cycle changed, i.e.
+            # when displays are supposed to be updated
+            signals 'appliedSnapshot(QDateTime)'
+
+            def initialize(parent, plan_rebuilder)
+                super(parent)
+                @list    = Qt::ListWidget.new(self)
+                @layout  = Qt::VBoxLayout.new(self)
+
+                def list.mouseReleaseEvent(event)
+                    if event.button == Qt::RightButton
+                        event.accept
+
+                        menu = Qt::Menu.new
+                        inspect_cycle = menu.add_action("Step-by-step from there")
+                        if action = menu.exec(event.globalPos)
+                            cycle_index = currentItem.data(Qt::UserRole).toInt
+
+                            rebuilder_widget = self.parentWidget
+                            stepping = Stepping.new(
+                                rebuilder_widget,
+                                rebuilder_widget.current_plan,
+                                rebuilder_widget.logfile.dup,
+                                cycle_index)
+                            stepping.exec
+                        end
+                    end
+                end
+
+                @layout.add_widget(@btn_create_display)
+                @history = Hash.new
+                @logfile = nil # set by #open
+                @plan_rebuilder = plan_rebuilder
+                @current_plan = DRoby::RebuiltPlan.new
+                @layout.add_widget(list)
+
+                Qt::Object.connect(list, SIGNAL('currentItemChanged(QListWidgetItem*,QListWidgetItem*)'),
+                           self, SLOT('currentItemChanged(QListWidgetItem*,QListWidgetItem*)'))
+            end
+
+
+            # Info about all tasks known within the stored history
+            #
+            # @return [(Set<Roby::Task>,Hash<Roby::Task,Roby::Task>)] returns
+            #   the set of all tasks stored in the history, as well as a mapping
+            #   from job placeholder tasks to the corresponding job task
+            def tasks_info
+                all_tasks = Set.new
+                all_job_info = Hash.new
+                history.each_key do |cycle_index|
+                    tasks, job_info = tasks_info_of_snapshot(cycle_index)
+                    all_tasks.merge(tasks)
+                    all_job_info.merge!(job_info)
+                end
+                return all_tasks, all_job_info
+            end
+
+            # Returns the set of tasks that are present in the given snapshot
+            #
+            # @return [Set<Roby::Task>]
+            def tasks_info_of_snapshot(cycle)
+                _, snapshot, * = history[cycle]
+                tasks = snapshot.plan.tasks.to_set
+                job_info = Hash.new
+                tasks.each do |t|
+                    if t.kind_of?(Roby::Interface::Job)
+                        planned_by_graph = snapshot.plan.task_relation_graph_for(Roby::TaskStructure::PlannedBy)
+                        placeholder_task = planned_by_graph.enum_for(:each_out_neighbour, t).first
+                        if placeholder_task
+                            job_info[placeholder_task] = t
+                        end
+                    end
+                end
+                return tasks, job_info
+            end
+
+            # Returns the job information for the given task in the given cycle
+            def job_placeholder_of(task, cycle)
+                if task.kind_of?(Roby::Interface::Job)
+                    _, snapshot, * = history[cycle]
+                    task.
+                        enum_parent_objects(snapshot.relations[Roby::TaskStructure::PlannedBy]).
+                        first
+                end
+            end
+
+            def add_missing_cycles(count)
+                item = Qt::ListWidgetItem.new(list)
+                item.setBackground(Qt::Brush.new(Qt::Color::fromHsv(33, 111, 255)))
+                item.flags = Qt::NoItemFlags
+                item.text = "[#{count} cycles missing]"
+            end
+
+            Snapshot = Struct.new :stats, :plan
+
+            def append_to_history
+                snapshot = Snapshot.new plan_rebuilder.stats.dup,
+                    DRoby::RebuiltPlan.new
+                snapshot.plan.merge(plan_rebuilder.plan)
+                if @last_snapshot
+                    snapshot.plan.dedupe(@last_snapshot.plan)
+                end
+                @last_snapshot = snapshot
+
+                cycle = snapshot.stats[:cycle_index]
+                time = Time.at(*snapshot.stats[:start]) + snapshot.stats[:actual_start]
+
+                item = Qt::ListWidgetItem.new(list)
+                item.text = "@#{cycle} - #{Roby.format_time(time)}"
+                item.setData(Qt::UserRole, Qt::Variant.new(cycle))
+                history[cycle] = [time, snapshot, item]
+                emit addedSnapshot(cycle)
+            end
+
+            signals 'addedSnapshot(int)'
+
+            slots 'currentItemChanged(QListWidgetItem*,QListWidgetItem*)'
+            def currentItemChanged(new_item, previous_item)
+                data = new_item.data(Qt::UserRole).toInt
+                apply(history[data][1])
+            end
+
+            def apply(snapshot)
+                @display_time = Time.at(*snapshot.stats[:start]) + snapshot.stats[:end]
+                @current_plan.clear
+                @current_plan.merge(snapshot.plan)
+                emit appliedSnapshot(Qt::DateTime.new(@display_time))
+            end
+
+            def seek(time)
+                # Convert from QDateTime to allow seek() to be a slot
+                if time.kind_of?(Qt::DateTime)
+                    time = Time.at(Float(time.toMSecsSinceEpoch) / 1000)
+                end
+
+                result = nil
+                history.each_value do |cycle_time, snapshot, item|
+                    if cycle_time < time
+                        if !result || result[0] < cycle_time
+                            result = [cycle_time, snapshot]
+                        end
+                    end
+                end
+                if result
+                    apply(result[1])
+                end
+            end
+            slots 'seek(QDateTime)'
+
+            def push_cycle(snapshot: true)
+                cycle = plan_rebuilder.stats[:cycle_index]
+                if last_cycle && (cycle != last_cycle + 1)
+                    add_missing_cycles(cycle - last_cycle - 1)
+                end
+                needs_snapshot =
+                    (plan_rebuilder.has_structure_updates? ||
+                     plan_rebuilder.has_event_propagation_updates?)
+                if snapshot && needs_snapshot
+                    append_to_history
+                end
+                @last_cycle = cycle
+                Time.at(*plan_rebuilder.stats[:start]) + plan_rebuilder.stats[:actual_start]
+            end
+            signals 'liveUpdate(QDateTime)'
+
+            def redraw(time = plan_rebuilder.current_time)
+                emit appliedSnapshot(Qt::DateTime.new(time))
+            end
+
+            # Opens +filename+ and reads the data from there
+            def open(filename)
+                @logfile = DRoby::Logfile::Reader.open(filename)
+                self.window_title = "roby-display: #{filename}"
+                emit sourceChanged
+                analyze
+                if !history.empty?
+                    apply(history[history.keys.sort.first][1])
+                end
+            end
+
+            signals 'sourceChanged()'
+
+            def self.analyze(plan_rebuilder, logfile, until_cycle: nil)
+                start_time, end_time = logfile.index.range
+
+                start = Time.now
+                puts "log file is #{(end_time - start_time).ceil}s long"
+                dialog = Qt::ProgressDialog.new("Analyzing log file", "Quit", 0, (end_time - start_time))
+                dialog.setWindowModality(Qt::WindowModal)
+                dialog.show
+
+                while !logfile.eof? && (!until_cycle || !plan_rebuilder.cycle_index || plan_rebuilder.cycle_index < until_cycle)
+                    data = logfile.load_one_cycle
+                    plan_rebuilder.process_one_cycle(data)
+                    if block_given?
+                        needs_snapshot =
+                            (plan_rebuilder.has_structure_updates? ||
+                             plan_rebuilder.has_event_propagation_updates?)
+                        yield(needs_snapshot, data) 
+                    end
+                    plan_rebuilder.clear_integrated
+                    dialog.setValue(plan_rebuilder.cycle_start_time - start_time)
+                    if dialog.wasCanceled
+                        Kernel.raise Interrupt
+                    end
+                end
+                dialog.dispose
+                puts "analyzed log file in %.2fs" % [Time.now - start]
+            end
+
+            def analyze(until_cycle: nil)
+                PlanRebuilderWidget.analyze(plan_rebuilder, logfile, until_cycle: until_cycle) do
+                    push_cycle
+                end
+            end
+
+            # Called when the connection to the log server failed, either
+            # because it has been closed or because creating the connection
+            # failed
+            def connection_failed(e, client, options)
+                @connection_error = e
+                emit warn("connection failed: #{e.message}")
+                if @reconnection_timer
+                    return
+                end
+
+                @reconnection_timer = Qt::Timer.new(self)
+                @connect_client  = client.dup
+                @connect_options = options.dup
+                @reconnection_timer.connect(SIGNAL('timeout()')) do
+                    puts "trying to reconnect to #{@connect_client} #{@connect_options}"
+                    if connect(@connect_client, @connect_options)
+                        emit info("Connected")
+                        @reconnection_timer.stop
+                        @reconnection_timer.dispose
+                        @reconnection_timer = nil
+                    end
+                end
+                @reconnection_timer.start(1000)
+            end
+
+            DEFAULT_REMOTE_POLL_PERIOD = 0.05
+
+            # Displays the data incoming from +client+
+            #
+            # +client+ is assumed to be a {DRoby::Logfile::Client} instance
+            #
+            # +update_period+ is, in seconds, the period at which the
+            # display will check whether there is new data on the port.
+            def connect(client, options = Hash.new)
+                options = Kernel.validate_options options,
+                    port: DRoby::Logfile::Server::DEFAULT_PORT,
+                    update_period: DEFAULT_REMOTE_POLL_PERIOD
+
+                if client.respond_to?(:to_str)
+                    self.window_title = "roby-display: #{client}"
+                    emit sourceChanged
+
+                    begin
+                        hostname = client
+                        client = DRoby::Logfile::Client.new(client, options[:port])
+                    rescue Exception => e
+                        connection_failed(e, client, options)
+                        return false
+                    end
+                end
+
+
+                @client = client
+                client.add_listener do |data|
+                    plan_rebuilder.clear_integrated
+                    plan_rebuilder.process_one_cycle(data)
+                    time = push_cycle
+                    emit liveUpdate(Qt::DateTime.new(time))
+
+                    cycle = plan_rebuilder.cycle_index
+                    time = plan_rebuilder.cycle_start_time
+                    emit info("@#{cycle} - #{time.strftime('%H:%M:%S.%3N')}")
+                end
+                @connection_pull = timer = Qt::Timer.new(self)
+                timer.connect(SIGNAL('timeout()')) do
+                    begin
+                        client.read_and_process_pending(max: 0.1)
+                    rescue Exception => e
+                        disconnect
+                        emit warn("Disconnected: #{e.message}")
+                        puts e.message
+                        puts "  " + e.backtrace.join("\n  ")
+                        if hostname
+                            connect(hostname, options)
+                        end
+                    end
+                end
+                timer.start(Integer(options[:update_period] * 1000))
+                return true
+            end
+
+            def disconnect
+                @client.disconnect
+                @connection_pull.stop
+                @connection_pull.dispose
+                @connection_pull = nil
+            end
+
+            def cycle_start_time
+                plan_rebuilder.cycle_start_time
+            end
+
+            # The start time of the first received cycle
+            def start_time
+                plan_rebuilder.start_time
+            end
+
+            # The end time of the last received cycle
+            def current_time
+                plan_rebuilder.current_time
+            end
+
+            # The time of the currently selected snapshot
+            def display_time
+                @display_time || start_time
+            end
+        end
+    end
+end
+
+

data/lib/roby/gui/qt4_toMSecsSinceEpoch.rb

@@ -0,0 +1,8 @@
+if !Qt::DateTime.method_defined?('toMSecsSinceEpoch')
+    class Qt::DateTime
+        def toMSecsSinceEpoch
+            toTime_t * 1000 + time.msec
+        end
+    end
+end
+

data/lib/roby/gui/relations_view.rb

@@ -0,0 +1,278 @@
+require 'roby/gui/relations_view/relations_config'
+require 'roby/gui/relations_view/relations_view_ui'
+require 'roby/gui/relations_view/relations_canvas'
+
+require 'roby/gui/plan_rebuilder_widget'
+require 'roby/gui/object_info_view'
+require 'roby/gui/scheduler_view'
+
+module Roby
+    module GUI
+        # Plan display that shows a snapshot of the event/task structure, as
+        # well as the events emitted within the last cycle
+        class RelationsView < Qt::Widget
+            attr_reader :ui
+            attr_reader :view
+            attr_reader :scheduler_view
+            attr_reader :history_widget
+
+            # In remote connections, this is he period between checking if
+            # there is data on the socket, in seconds
+            #
+            # See #connect
+            def initialize(history_widget, parent = nil)
+                super(parent)
+                @ui = Ui::RelationsView.new
+                ui.setupUi(self)
+                @scheduler_view = SchedulerView.new(ui.scheduler_view_holder)
+                @scheduler_view_layout = Qt::VBoxLayout.new(ui.scheduler_view_holder)
+                @scheduler_view_layout.add_widget scheduler_view
+                scheduler_view.show
+
+                @history_widget = history_widget
+                @view = RelationsCanvas.new([history_widget.current_plan])
+                ui.setupActions(self)
+                ui.graphics.scene = view.scene
+
+                resize 500, 500
+            end
+
+            # Slot used to make the widget update its title when e.g. the
+            # underlying history widget changed its source
+            def updateWindowTitle
+                if parent_title = history_widget.window_title
+                    self.window_title = history_widget.window_title + ": Relations"
+                else
+                    self.window_title = "roby-display: Relations"
+                end
+            end
+            slots 'updateWindowTitle()'
+
+            def setDisplayTime(time)
+                scheduler_view.display(history_widget.current_plan.consolidated_scheduler_state)
+                view.update(time)
+            end
+            slots 'setDisplayTime(QDateTime)'
+
+            def update_time_range(start_time, current_time)
+            end
+            def update_display_time(time)
+                scheduler_view.display(history_widget.current_plan.consolidated_scheduler_state)
+                view.update(time)
+            end
+
+            def save_options
+                view.save_options
+            end
+
+            def apply_options(options)
+                view.apply_options(options)
+            end
+        end
+    end
+end
+
+
+class Ui::RelationsView
+    def scene; graphics.scene end
+
+    # The underlying RelationsCanvas object
+    attr_reader :display
+    attr_reader :prefixActions
+    attr_reader :verticalLayout
+    attr_reader :graphics
+
+    # Module used to extend the relation view GraphicsView object, to add
+    # double-click and context-menu events
+    module GraphicsViewBehaviour
+        attr_accessor :display
+
+        def mouseDoubleClickEvent(event)
+            item = itemAt(event.pos)
+            if item
+                obj = display.object_of(item) ||
+                    display.relation_of(item)
+
+                if !obj
+                    return super(event)
+                end
+            end
+
+            @object_info ||= Roby::GUI::ObjectInfoView.new
+            if @object_info.display(obj)
+                @object_info.activate
+            end
+        end
+
+        def contextMenuEvent(event)
+            item = itemAt(event.pos)
+            if item
+                unless obj = display.object_of(item)
+                    return super(event)
+                end
+            end
+
+            return unless obj.kind_of?(Roby::Task)
+
+            menu = Qt::Menu.new
+            hide_this     = menu.add_action("Hide")
+            hide_children = menu.add_action("Hide children")
+            show_children = menu.add_action("Show children")
+            return unless action = menu.exec(event.globalPos)
+
+            case action.text
+            when "Hide"
+                display.selected_objects.delete(obj)
+            when "Hide children"
+                obj.plan.compute_useful_tasks([obj]).each do |child|
+                    if child != obj
+                        display.selected_objects.delete(child)
+                    end
+                end
+            when "Show children"
+                obj.plan.compute_useful_tasks([obj]).each do |child|
+                    if child != obj
+                        display.selected_objects << child
+                    end
+                end
+            end
+
+            display.update
+        end
+    end
+
+    ZOOM_STEP = 0.25
+    def setupActions(view)
+        @display   = display = view.view
+
+        @actionShowAll = Qt::Action.new(view)
+        @actionShowAll.objectName = "actionShowAll"
+        @actionShowAll.text = "Show All"
+        @actionRedraw = Qt::Action.new(view)
+        @actionRedraw.objectName = "actionRedraw"
+        @actionRedraw.text = "Redraw"
+        @actionZoom = Qt::Action.new(view)
+        @actionZoom.objectName = "actionZoom"
+        @actionZoom.text = "Zoom +"
+        @actionUnzoom = Qt::Action.new(view)
+        @actionUnzoom.objectName = "actionUnzoom"
+        @actionUnzoom.text = "Zoom -"
+        @actionFit = Qt::Action.new(view)
+        @actionFit.objectName = "actionFit"
+        @actionFit.text = "Fit View"
+        @actionOwnership = Qt::Action.new(view)
+        @actionOwnership.objectName = "actionOwnership"
+        @actionOwnership.text = "Display Ownership"
+        @actionOwnership.checkable = true
+        @actionOwnership.checked = true
+        @actionSVGExport = Qt::Action.new(view)
+        @actionSVGExport.objectName = "actionSVGExport"
+        @actionSVGExport.text = "SVG Export"
+        @actionPrint = Qt::Action.new(view)
+        @actionPrint.objectName = "actionPrint"
+        @actionPrint.text = "Print"
+        @actionKeepSignals = Qt::Action.new(view)
+        @actionKeepSignals.objectName = "actionKeepSignals"
+        @actionKeepSignals.text = "Keep Signals"
+        @actionKeepSignals.checkable = true
+        @actionKeepSignals.checked = false
+        @actionBookmarksAdd = Qt::Action.new(view)
+        @actionBookmarksAdd.objectName = "actionBookmarksAdd"
+        @actionBookmarksAdd.text = "Add Bookmark"
+        @actionHideFinalized = Qt::Action.new(view)
+        @actionHideFinalized.objectName = "actionHideFinalized"
+        @actionHideFinalized.text = "Hide Finalized"
+        @actionHideFinalized.checkable = true
+        @actionHideFinalized.checked = true
+        @actionConfigure = Qt::Action.new(view)
+        @actionConfigure.objectName = "actionConfigure"
+        @actionConfigure.text = "Configure"
+
+        @menubar = Qt::MenuBar.new(view)
+        @menubar.objectName = "menubar"
+        @menubar.geometry = Qt::Rect.new(0, 0, 800, 21)
+        @menuView = Qt::Menu.new("View", @menubar)
+        @menuView.objectName = "menuView"
+
+        @menubar.addAction(@menuView.menuAction())
+        @menuView.addAction(@actionKeepSignals)
+        @menuView.addAction(@actionShowAll)
+        @menuView.addSeparator()
+        @menuView.addAction(@actionZoom)
+        @menuView.addAction(@actionUnzoom)
+        @menuView.addAction(@actionFit)
+        @menuView.addSeparator()
+        @menuView.addAction(@actionSVGExport)
+        @menuView.addAction(@actionPrint)
+        @menuView.addAction(@actionConfigure)
+
+        @verticalLayout.setMenuBar(@menubar)
+
+        @actionConfigure.connect(SIGNAL(:triggered)) do
+            if !@configuration_widget
+                @configuration_widget = Qt::Widget.new
+                @configuration_widget_ui = Ui::RelationsConfig.new(@configuration_widget, display)
+            end
+            @configuration_widget.show
+        end
+        
+        #############################################################
+        # Handle the other toolbar's buttons
+        graphics.extend GraphicsViewBehaviour
+        graphics.display = display
+
+        @actionShowAll.connect(SIGNAL(:triggered)) do
+            display.graphics.keys.each do |obj|
+                display.set_visibility(obj, true) if obj.kind_of?(Roby::Task::DRoby) || (obj.kind_of?(Roby::EventGenerator::DRoby) && !obj.respond_to?(:task))
+            end
+            display.update
+        end
+
+        @actionZoom.connect(SIGNAL(:triggered)) do 
+            scale = graphics.matrix.m11
+            if scale + ZOOM_STEP > 1
+                scale = 1 - ZOOM_STEP
+            end
+            graphics.resetMatrix
+            graphics.scale scale + ZOOM_STEP, scale + ZOOM_STEP
+        end
+        @actionUnzoom.connect(SIGNAL(:triggered)) do
+            scale = graphics.matrix.m11
+            graphics.resetMatrix
+            graphics.scale scale - ZOOM_STEP, scale - ZOOM_STEP
+        end
+        @actionFit.connect(SIGNAL(:triggered)) do
+            graphics.fitInView(graphics.scene.items_bounding_rect, Qt::KeepAspectRatio)
+        end
+
+        @actionKeepSignals.connect(SIGNAL(:triggered)) do 
+            display.keep_signals = @actionKeepSignals.checked?
+        end
+
+        @actionPrint.connect(SIGNAL(:triggered)) do
+            return unless scene
+            printer = Qt::Printer.new;
+            if Qt::PrintDialog.new(printer).exec() == Qt::Dialog::Accepted
+                painter = Qt::Painter.new(printer);
+                painter.setRenderHint(Qt::Painter::Antialiasing);
+                scene.render(painter);
+            end
+        end
+
+        @actionSVGExport.connect(SIGNAL(:triggered)) do
+            return unless scene
+
+            if path = Qt::FileDialog.get_save_file_name(nil, "SVG Export")
+                svg = Qt::SvgGenerator.new
+                svg.file_name = path
+                svg.size = Qt::Size.new(Integer(scene.width * 0.8), Integer(scene.height * 0.8))
+                painter = Qt::Painter.new
+                painter.begin(svg)
+                scene.render(painter)
+                painter.end
+            end
+        end
+        @actionSVGExport.enabled = defined?(Qt::SvgGenerator)
+    end
+end
+