roby 0.8.0 → 3.0.0

data/lib/roby/gui/dot_id.rb

@@ -0,0 +1,11 @@
+class Object
+    def dot_id
+        id = object_id
+        id = if id < 0
+                 (0xFFFFFFFFFFFFFFFF + id).to_s
+             else
+                 id.to_s
+             end
+        "object_#{id}"
+    end
+end

data/lib/roby/gui/exception_view.rb

@@ -0,0 +1,44 @@
+module Roby
+    module GUI
+        class ExceptionRendering < MetaRuby::GUI::ExceptionRendering
+            attr_reader :excluded_patterns
+
+            def initialize(*)
+                super
+                @excluded_patterns = Regexp.new("^$")
+            end
+
+            def add_excluded_pattern(rx)
+                @excluded_patterns = Regexp.union(excluded_patterns, rx)
+            end
+
+            def each_exception_from(e)
+                super do |e|
+                    yield e
+                    if e.respond_to?(:original_exceptions)
+                        e.original_exceptions.each do |original_e|
+                            each_exception_from(original_e, &Proc.new)
+                        end
+                    end
+                end
+            end
+
+            def filter_backtrace(parsed_backtrace, raw_backtrace)
+                raw_backtrace = raw_backtrace.
+                    find_all { |l| !(excluded_patterns === l) }
+                Roby.filter_backtrace(raw_backtrace, force: true)
+            end
+
+            def user_file?(file)
+                Roby.app.app_file?(file)
+            end
+        end
+
+        class ExceptionView < MetaRuby::GUI::ExceptionView
+            def initialize(*)
+                super
+                @exception_rendering = ExceptionRendering.new(self.exception_rendering.linker)
+            end
+        end
+    end
+end

data/lib/roby/gui/log_display.rb

@@ -0,0 +1,273 @@
+require 'Qt4'
+require 'roby/gui/plan_rebuilder_widget'
+require 'roby/gui/relations_view'
+require 'roby/gui/chronicle_view'
+
+module Roby
+    module GUI
+        # Main UI for log display
+        #
+        # It includes
+        class LogDisplay < Qt::Widget
+            # The PlanRebuilder object that gets the data
+            attr_reader :plan_rebuilder
+            # The history widget
+            attr_reader :history_widget
+            # The set of displays that have been created so far
+            #
+            # It is managed as a mapping from the view class name to an array of
+            # views. The array can contain nil elements. This is used to restore
+            # configurations across software restarts (i.e. the index is used as
+            # an ID for the widget)
+            attr_reader :displays
+            # The Qt::PushButton object that allows to create new displays
+            attr_reader :btn_create_display
+            # The label widget that is used to display information/warning
+            # messages
+            attr_reader :lbl_info
+            # The menu button to create new displays
+            attr_reader :menu_displays
+
+            class << self
+                # Registered plan displays
+                #
+                # It is a mapping from the displayed name (shown to the users)
+                # to the name of the underlying class
+                attr_reader :available_displays
+            end
+            @available_displays =
+                { 'Relations' => 'Roby::GUI::RelationsView',
+                  'Chronicle' => 'Roby::GUI::ChronicleView' }
+
+            def initialize(parent = nil, plan_rebuilder = nil)
+                super
+
+                plan_rebuilder ||= DRoby::PlanRebuilder.new
+                @plan_rebuilder = plan_rebuilder
+
+                @displays = Hash.new { |h, k| h[k] = Array.new }
+
+                @btn_create_display = Qt::PushButton.new("New Display", self)
+                @lbl_info = Qt::Label.new(self)
+                @history_widget = PlanRebuilderWidget.new(self, plan_rebuilder)
+                @layout = Qt::VBoxLayout.new(self)
+                @layout.add_widget(@btn_create_display)
+                @layout.add_widget(@lbl_info)
+                @layout.add_widget(@history_widget)
+
+                Qt::Object.connect(history_widget, SIGNAL('sourceChanged()'),
+                                   self, SLOT('updateWindowTitle()'))
+                Qt::Object.connect(history_widget, SIGNAL('info(QString)'),
+                                   self, SLOT('info(QString)'))
+                Qt::Object.connect(history_widget, SIGNAL('warn(QString)'),
+                                   self, SLOT('warn(QString)'))
+
+                btn_create_display.text = "New Display"
+                @menu_displays = Qt::Menu.new(@btn_create_display)
+                self.class.available_displays.each do |name, klass_name|
+                    action = menu_displays.addAction(name)
+                    action.setData(Qt::Variant.new(klass_name))
+                end
+                btn_create_display.setMenu(menu_displays)
+                menu_displays.connect(SIGNAL('triggered(QAction*)')) do |action|
+                    create_display(action.data.toString)
+                end
+
+                resize(300, 500)
+            end
+
+            def updateWindowTitle
+                self.window_title = history_widget.window_title
+            end
+            slots 'updateWindowTitle()'
+
+            def create_all_displays
+                self.class.available_displays.each do |user_name, klass_name|
+                    create_display(klass_name)
+                end
+            end
+
+            def allocate_id(klass_name)
+                displays[klass_name].size
+            end
+
+            def display_from_id(klass_name, id)
+                displays[klass_name][id]
+            end
+
+            def create_display(name, id = nil)
+                # Check whether +klass_name+ is not a user-visible string
+                self.class.available_displays.each do |user_name, klass_name|
+                    if user_name.downcase == name.downcase
+                        name = klass_name
+                        break
+                    end
+                end
+
+                id ||= allocate_id(name)
+                if displays[name][id]
+                    raise ArgumentError, "there is already a view of type #{name} with ID #{id}"
+                end
+
+                klass = begin constant(name)
+                        rescue NameError => e
+                            Roby.warn "cannot create display of class #{name}: #{e}"
+                            return
+                        end
+
+                log_display = self
+                view = klass.new(@history_widget)
+                view.singleton_class.class_eval do
+                    define_method :closeEvent do |event|
+                        log_display.remove_display(name, id)
+                        event.accept
+                    end
+                end
+                if view.respond_to?(:live=)
+                    view.live = false
+                end
+                connect_display(history_widget, view)
+                view.setAttribute(Qt::WA_QuitOnClose, false)
+
+                view.show
+                displays[name][id] = view
+            end
+
+            def remove_display(name, id)
+                view = displays[name][id]
+                displays[name][id] = nil
+                disconnect_display(history_widget, view)
+            end
+
+            def connect_display(history_widget, view)
+                if history_widget.start_time && history_widget.current_time
+                    view.update_time_range(history_widget.start_time, history_widget.current_time)
+                    view.update_display_time(history_widget.display_time)
+                end
+                Qt::Object.connect(history_widget, SIGNAL('appliedSnapshot(QDateTime)'),
+                                   view, SLOT('setDisplayTime(QDateTime)'))
+                Qt::Object.connect(history_widget, SIGNAL('liveUpdate(QDateTime)'),
+                                   view, SLOT('setCurrentTime(QDateTime)'))
+                Qt::Object.connect(history_widget, SIGNAL('sourceChanged()'),
+                                   view, SLOT('updateWindowTitle()'))
+            end
+
+            def disconnect_display(history_widget, view)
+                Qt::Object.disconnect(history_widget, SIGNAL('appliedSnapshot(QDateTime)'),
+                                   view, SLOT('setDisplayTime(QDateTime)'))
+                Qt::Object.disconnect(history_widget, SIGNAL('liveUpdate(QDateTime)'),
+                                   view, SLOT('setCurrentTime(QDateTime)'))
+                Qt::Object.disconnect(history_widget, SIGNAL('sourceChanged()'),
+                                   view, SLOT('updateWindowTitle()'))
+            end
+
+            def info(message)
+                lbl_info.text = message
+            end
+            slots 'info(QString)'
+
+            def warn(message)
+                lbl_info.setText("<font color=\"red\">#{message}</font>")
+            end
+            slots 'warn(QString)'
+
+            # Opens +filename+ and reads the data from there
+            def open(filename)
+                history_widget.open(filename)
+            end
+
+            # 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)
+                history_widget.connect(client, options)
+            end
+
+            # Creates a new display that will display the information
+            # present in +filename+
+            #
+            # +plan_rebuilder+, if given, will be used to rebuild a complete
+            # data structure based on the information in +filename+
+            def self.from_file(filename, plan_rebuilder = nil)
+                view = new(plan_rebuilder)
+                view.open(filename)
+                view
+            end
+
+            def load_options(path)
+                if new_options = YAML.load(File.read(path))
+                    apply_options(new_options)
+                end
+            end
+
+            def save_options
+                options = Hash.new
+                options['main'] = Hash.new
+                options['plugins'] = Roby.app.plugins.map(&:first)
+                save_widget_state(options['main'], self)
+                options['views'] = Array.new
+                displays.each do |klass_name, views|
+                    views.each_with_index do |view, id|
+                        next if !view
+                        view_options = Hash.new
+                        view_options["class"] = view.class.name
+                        view_options['id'] = id
+                        save_widget_state(view_options, view)
+
+                        if view.respond_to?(:save_options)
+                            view_options.merge!(view.save_options)
+                        end
+                        options['views'] << view_options
+                    end
+                end
+                options
+            end
+
+            def save_widget_state(options, widget)
+                options['geometry'] =
+                    [widget.geometry.x, widget.geometry.y,
+                        widget.geometry.width, widget.geometry.height]
+            end
+
+            def apply_widget_state(options, widget)
+                if geom = options['geometry']
+                    widget.set_geometry(*geom)
+                end
+            end
+
+            def apply_options(options)
+                (options['plugins'] || Array.new).each do |plugin_name|
+                    begin
+                        Roby.app.using plugin_name
+                    rescue ArgumentError => e
+                        Roby.warn "the display configuration file mentions the #{plugin_name} plugin, but it is not available on this system. Some information might not be displayed"
+                    end
+                end
+
+                filters = options['plan_rebuilder'] || Hash.new
+                apply_widget_state(options['main'] || Hash.new, self)
+                (options['views'] || Array.new).each do |view_options|
+                    id = view_options['id']
+                    klass_name = view_options["class"]
+                    if w = display_from_id(klass_name, id)
+                        if w.class.name != klass_name
+                            next
+                        end
+                    else
+                        if !(w = create_display(klass_name, id))
+                            next
+                        end
+                    end
+                    apply_widget_state(view_options, w)
+                    if w.respond_to?(:apply_options)
+                        w.apply_options(view_options)
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/gui/model_views.rb

@@ -0,0 +1,2 @@
+require 'roby/gui/model_views/action_interface'
+require 'roby/gui/model_views/task'

data/lib/roby/gui/model_views/action_interface.rb

@@ -0,0 +1,53 @@
+module Roby
+    module GUI
+        module ModelViews
+            # Handler class to display information about an action interface
+            class ActionInterface < MetaRuby::GUI::HTML::Collection
+                def initialize(page)
+                    super
+                end
+
+                def compute_toplevel_links(model, options)
+                    actions = model.each_action.map do |action|
+                        arguments = action.arguments.map { |arg| ":#{arg.name}" }.join(", ")
+                        format = "#{action.name}(#{arguments}) => #{page.link_to(action.returned_type)}: #{action.doc}"
+                        Element.new(action.name, format, element_link_target(action, options[:interactive]), action.name, Hash.new)
+                    end
+                end
+
+                def render(model, options = Hash.new)
+                    ActionInterface.html_defined_in(page, model, with_require: true)
+
+                    actions = compute_toplevel_links(model, options)
+                    render_links('Actions', actions)
+                end
+
+                def self.find_definition_place(model)
+                    location = model.definition_location.find do |location|
+                        return if location.label == 'require' || location.label == 'using_task_library'
+                        Roby.app.app_file?(location.absolute_path)
+                    end
+                    if location
+                        return location.absolute_path, location.lineno
+                    end
+                end
+
+                def self.html_defined_in(page, model, with_require: true, definition_location: nil, format: "<b>Defined in</b> %s")
+                    path, lineno = *definition_location || find_definition_place(model)
+                    if path
+                        path = Pathname.new(path)
+                        path_link = page.link_to(path, "#{path}:#{lineno}", lineno: lineno)
+                        page.push(nil, "<p>#{format % [path_link]}</p>")
+                        if with_require
+                            if req_base = $LOAD_PATH.find { |p| path.fnmatch?(File.join(p, "*")) }
+                                req = path.relative_path_from(Pathname.new(req_base))
+                                page.push(nil, "<code>require '#{req.sub_ext("")}'</code>")
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/gui/model_views/task.rb

@@ -0,0 +1,47 @@
+require 'roby/gui/relations_view/relations_canvas'
+
+module Roby
+    module GUI
+        module ModelViews
+            # Handler class to display information about a task model
+            class Task < Qt::Object
+                attr_reader :page
+
+                def initialize(page)
+                    @page = page
+                    super()
+                end
+                def enable
+                end
+                def disable
+                end
+                def clear
+                end
+
+                TEMPLATE_PATH = File.expand_path('task.rhtml', File.dirname(__FILE__))
+                TEMPLATE = ERB.new(File.read(TEMPLATE_PATH))
+                TEMPLATE.filename = TEMPLATE_PATH
+
+                def render(task_model, options = Hash.new)
+                    html = TEMPLATE.result(binding)
+                    svg  = RelationsCanvasTask.to_svg(task_model.new(plan: DRoby::RebuiltPlan.new))
+
+                    options, push_options = Kernel.filter_options options,
+                        external_objects: false, doc: true
+                    if external_objects = options[:external_objects]
+                        file = external_objects % 'roby_task' + ".svg"
+                        File.open(file, 'w') { |io| io.write(svg) }
+                        svg = "<object data=\"#{file}\" type=\"image/svg+xml\"></object>"
+                    end
+
+                    if options[:doc] && task_model.doc
+                        page.push nil, page.main_doc(task_model.doc)
+                    end
+                    page.push('Roby Task Model', TEMPLATE.result(binding), push_options)
+                end
+
+                signals 'updated()'
+            end
+        end
+    end
+end

data/lib/roby/gui/model_views/task.rhtml

@@ -0,0 +1,41 @@
+<%
+ancestry = [task_model]
+while ancestry.last != Roby::Task
+    ancestry << ancestry.last.superclass
+end
+ancestry.shift
+%>
+<p><b>Superclasses</b>: <%= ancestry.map { |m| page.link_to(m) }.join(", ") %></p>
+
+<%
+events = task_model.each_event.map { |_, ev| ev }.sort_by { |ev| ev.symbol.to_s }
+events = events.map do |ev|
+    flags = []
+    if ev.controlable?
+        flags << "controlable"
+    end
+    if ev.terminal?
+        flags << "terminal"
+    end
+    if flags.empty?
+        flags = ""
+    else flags = "<span id=\"annotation-inline\">(#{flags.join(",")})</span>"
+    end
+    "#{ev.symbol}#{flags}"
+end
+%>
+<p><b>Events</b>: <%= events.join(", ") %></p>
+
+<%
+arguments = task_model.arguments
+arguments = arguments.map do |arg_name|
+    has_default, default = task_model.default_argument(arg_name)
+    if has_default
+        default = " <span id=\"annotation-inline\">default(#{default})</span>"
+    end
+    "#{arg_name}#{default}"
+end
+%>
+<p><b>Arguments</b>: <%= arguments.join(", ") %></p>
+
+<%= svg %>