roby 0.8.0 → 3.0.0

data/lib/roby/gui/relations_view/relations_config.rb

@@ -0,0 +1,292 @@
+require 'roby/gui/relations_view/relations_ui'
+
+module Ui
+    # Manage relations using a two-level tree structure. The relation
+    # categories (tasks and events) have a model index of (row, column, nil)
+    # while the relations have a model index of (row, column, category), where
+    # category is TASK_ROOT_INDEX for task relations and EVENT_ROOT_INDEX for
+    # event relations
+    class RelationConfigModel < Qt::AbstractItemModel
+        COL_NAME    = 0
+        COL_COLOR   = 1
+
+        TASK_ROOT_INDEX  = 0
+        EVENT_ROOT_INDEX = 1
+        CATEGORIES = ['Task structure']
+
+        def event_root_index; createIndex(EVENT_ROOT_INDEX, 0, -1) end
+        def task_root_index;  createIndex(TASK_ROOT_INDEX, 0, -1) end
+
+        attr_reader :relations
+        attr_reader :display
+        def initialize(display)
+            super()
+
+            @current_color = 0
+            @display   = display
+            @relations = []
+
+            relations[TASK_ROOT_INDEX]  = Roby::TaskStructure.relations.to_a
+
+            RelationConfigModel.detect_qtruby_behaviour(createIndex(0, 0, 0))
+        end
+
+        QTRUBY_INDEX_USING_POINTERS  = 1
+        QTRUBY_INDEX_USING_OBJECTIDS = 2
+        def self.detect_qtruby_behaviour(idx)
+            if idx.internalPointer == 0
+                @@qtruby_behaviour = QTRUBY_INDEX_USING_POINTERS
+            elsif idx.internalId == 1
+                @@qtruby_behaviour = QTRUBY_INDEX_USING_OBJECTIDS
+            end
+        end
+
+        def self.category_from_index(idx)
+            if @@qtruby_behaviour == QTRUBY_INDEX_USING_POINTERS
+                idx.internalPointer
+            else
+                idx.internalId >> 1
+            end
+        end
+
+        def index(row, column, parent)
+            if parent.valid? && RelationConfigModel.category_from_index(parent) == -1
+                createIndex(row, column, parent.row)
+            elsif row < relations.size
+                createIndex(row, column, -1)
+            else
+                Qt::ModelIndex.new
+            end
+        end
+
+        def parent(index)
+            category = RelationConfigModel.category_from_index(index)
+            if !index.valid? || category == -1 then Qt::ModelIndex.new
+            else createIndex(category, 0, -1) end
+        end
+        def columnCount(parent); 2 end
+        def hasChildren(parent); !parent.valid? || RelationConfigModel.category_from_index(parent) == -1 end
+        def rowCount(parent)
+            if !parent.valid? then relations.size
+            else relations[parent.row].size end
+        end
+        def headerData(section, orientation, role)
+            return Qt::Variant.new unless role == Qt::DisplayRole && orientation == Qt::Horizontal
+            value = if section == 0 then "Relation"
+                    else "Color" end
+            Qt::Variant.new(value)
+        end
+        def data(index, role)
+            return Qt::Variant.new unless index.valid?
+
+            category = RelationConfigModel.category_from_index(index)
+            value = if category == -1
+                        if index.column == COL_NAME && role == Qt::DisplayRole
+                            CATEGORIES[index.row]
+                        end
+                    else
+                        relation = relations[category][index.row]
+                        if index.column == COL_NAME && role == Qt::CheckStateRole
+                            if    display.relation_enabled?(relation) then Qt::Checked.to_i
+                            elsif display.layout_relation?(relation)  then Qt::PartiallyChecked.to_i
+                            else Qt::Unchecked.to_i
+                            end
+                        elsif index.column == COL_NAME && role == Qt::DisplayRole
+                            relation.name.gsub(/.*Structure::/, '')
+                        elsif index.column == COL_COLOR && role == Qt::DisplayRole
+                            display.relation_color(relation)
+                        end
+                    end
+
+            if value then Qt::Variant.new(value)
+            else Qt::Variant.new
+            end
+        end
+        def setData(index, value, role)
+            category = RelationConfigModel.category_from_index(index)
+            relation = relations[category][index.row]
+            if role == Qt::CheckStateRole
+                case value.to_i
+                when Qt::Checked.to_i
+                    display.enable_relation(relation)
+                when Qt::PartiallyChecked.to_i
+                    display.layout_relation(relation)
+                else
+                    display.ignore_relation(relation)
+                end
+            else
+                display.update_relation_color(relation, value.to_string)
+            end
+            display.update
+            emit dataChanged(index, index)
+        end
+        def flags(index)
+            if !index.valid? || RelationConfigModel.category_from_index(index) == -1 then Qt::ItemIsEnabled 
+            else 
+                flags = Qt::ItemIsSelectable | Qt::ItemIsTristate | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable
+                if index.column == 1
+                    flags = Qt::ItemIsEditable | flags
+                end
+                flags
+            end
+        end
+    end
+    class RelationDelegate < Qt::ItemDelegate
+        MAX_WIDTH = 50
+        def createEditor(parent, option, index)
+            color = index.model.data(index, Qt::DisplayRole).to_string
+            new_color = Qt::ColorDialog.get_color(Qt::Color.new(color))
+            index.model.setData(index, Qt::Variant.new(new_color.name), Qt::DisplayRole)
+
+            nil
+        end
+        def paint(painter, option, index)
+            if index.column == 1 && RelationConfigModel.category_from_index(index) >= 0
+                color = index.model.data(index, Qt::DisplayRole).to_string
+                rect = option.rect
+                rect.adjust(1, 1, -1, -1)
+                if rect.width > MAX_WIDTH
+                    rect.width = MAX_WIDTH
+                end
+                painter.fill_rect rect, Qt::Brush.new(Qt::Color.new(color))
+            else
+                super
+            end
+        end
+    end
+
+    class LayoutMethodModel < Qt::AbstractListModel
+        METHODS    = ["Auto", "dot [rankdir=LR]", "dot [rankdir=TB]", "circo", "neato [overlap=false]", "neato [overlap=false,mode=hier]", "twopi", "fdp"]
+        attr_reader :display, :combo
+        def initialize(display, combo)
+            super()
+            @display, @combo = display, combo
+        end
+
+        def rowCount(parent)
+            return 0 if parent.valid?
+            return METHODS.size
+        end
+        def data(index, role)
+            return Qt::Variant.new unless role == Qt::DisplayRole && index.valid?
+            Qt::Variant.new(METHODS[index.row])
+        end
+        def layout_method(index)
+        end
+
+        def flags(index)
+            Qt::ItemIsSelectable | Qt::ItemIsEnabled
+        end
+
+        def selected
+            index = combo.current_index
+            display.layout_method =
+                if index == 0 then nil
+                else METHODS[index]
+                end
+            display.update
+        end
+        slots 'selected()'
+    end
+
+    class RelationsConfig
+        attr_reader :current_color
+        attr_reader :relation_color
+        attr_reader :relation_item
+        attr_reader :model
+        attr_reader :delegate
+        attr_reader :display
+
+        def initialize(widget, display)
+            super()
+            if !system("dot", "-V")
+                raise "the 'dot' tool is unavailable"
+            end
+
+            setupUi(widget, display)
+        end
+
+        def setupUi(widget, display)
+            super(widget)
+
+            @display = display
+            @model    = RelationConfigModel.new(display)
+            @delegate = RelationDelegate.new
+            relations.set_item_delegate @delegate
+            relations.header.resize_mode = Qt::HeaderView::Stretch
+            relations.model = @model
+            relations.set_expanded model.task_root_index, true
+            relations.set_expanded model.event_root_index, true
+
+            @layout_model = LayoutMethodModel.new(display, layoutMethod)
+            Qt::Object.connect(layoutMethod, SIGNAL("currentIndexChanged(int)"), @layout_model, SLOT("selected()"))
+            layoutMethod.model = @layout_model
+
+            showOwnership.checked = display.show_ownership
+            showOwnership.connect(SIGNAL('clicked(bool)')) do |state|
+                display.show_ownership = state
+                display.update
+            end
+            showFinalized.checked = !display.hide_finalized
+            showFinalized.connect(SIGNAL('clicked(bool)')) do |state|
+                display.hide_finalized = !state
+                display.update
+            end
+            removedPrefixes.setText(display.removed_prefixes.to_a.join(","))
+            removedPrefixes.connect(SIGNAL('textChanged(QString)')) do |removed_prefixes|
+                display.removed_prefixes = removed_prefixes.split(',')
+                delayed_update
+            end
+            hiddenLabels.setText(display.hidden_labels.to_a.join(","))
+            hiddenLabels.connect(SIGNAL('textChanged(QString)')) do |hidden_labels|
+                display.hidden_labels = hidden_labels.split(',')
+                delayed_update
+            end
+            if display.display_policy == :explicit
+                displayExplicit.checked = true
+            elsif display.display_policy == :emitters
+                displayEmitters.checked = true
+            elsif display.display_policy == :emitters_and_parents
+                displayEmittersAndParents.checked = true
+            end
+
+            displayExplicit.connect(SIGNAL('clicked()')) do
+                display.display_policy = :explicit
+                delayed_update
+            end
+            displayEmitters.connect(SIGNAL('clicked()')) do
+                display.display_policy = :emitters
+                delayed_update
+            end
+            displayEmittersAndParents.connect(SIGNAL('clicked()')) do
+                display.display_policy = :emitters_and_parents
+                delayed_update
+            end
+
+            @delayed_update_timer = Qt::Timer.new(display)
+            @delayed_update_timer.setSingleShot(true)
+            @delayed_update_timer.connect(SIGNAL('timeout()')) do
+                display.update
+            end
+        end
+
+        # The amount of time we wait before triggering an update on the display.
+        # This is meant to avoid unnecessary updates (for instance for
+        # configuration parameters in textboxes)
+        DELAYED_UPDATE_TIMEOUT = 500
+
+        def delayed_update
+            @delayed_update_timer.start(DELAYED_UPDATE_TIMEOUT)
+        end
+    end
+end
+
+if $0 == __FILE__
+    a = Qt::Application.new(ARGV)
+    u = Ui::RelationsConfig.new
+    w = Qt::Widget.new
+    u.setupUi(w)
+    w.show
+    a.exec
+end
+

data/lib/roby/gui/relations_view/relations_view.ui

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>RelationsView</class>
+ <widget class="QWidget" name="RelationsView">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>948</width>
+    <height>683</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Roby Display</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QSplitter" name="splitter">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <widget class="QGraphicsView" name="graphics">
+      <property name="sizePolicy">
+       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+        <horstretch>10</horstretch>
+        <verstretch>0</verstretch>
+       </sizepolicy>
+      </property>
+      <property name="minimumSize">
+       <size>
+        <width>250</width>
+        <height>250</height>
+       </size>
+      </property>
+      <property name="renderHints">
+       <set>QPainter::Antialiasing|QPainter::TextAntialiasing</set>
+      </property>
+     </widget>
+     <widget class="QWidget" name="scheduler_view_holder" native="true">
+      <property name="minimumSize">
+       <size>
+        <width>0</width>
+        <height>100</height>
+       </size>
+      </property>
+     </widget>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

data/lib/roby/gui/scheduler_view.css

@@ -0,0 +1,24 @@
+section {
+    display: block;
+    margin-bottom: 2em;
+}
+section title {
+    display: block;
+    font-size: 110%;
+}
+section non_scheduled_tasks title {
+    display: block;
+}
+section actions title {
+    display: block;
+}
+called_generators, non_scheduled_tasks, reasons, actions, descriptions {
+    display: block;
+    left-border: solid;
+    margin-left: .5em;
+    padding-left: .5em;
+}
+item {
+    display: block;
+    margin-left: 1em;
+}

data/lib/roby/gui/scheduler_view.rb

@@ -0,0 +1,46 @@
+require 'erb'
+require 'qtwebkit'
+module Roby
+    module GUI
+        class SchedulerView < Qt::WebView
+            def ressources_dir
+                File.expand_path(File.dirname(__FILE__))
+            end
+
+            def scheduler_view_css
+                File.join(ressources_dir, "scheduler_view.css")
+            end
+
+            def scheduler_view_rhtml
+                File.join(ressources_dir, "scheduler_view.rhtml")
+            end
+
+            def erb
+                if !@erb
+                    template = File.read(scheduler_view_rhtml)
+                    @erb = ERB.new(template)
+                end
+                return @erb
+            end
+
+            def format_msg_string(msg, *args)
+                args.each_with_index.inject(msg) do |msg, (a, i)|
+                    a = if a.respond_to?(:map)
+                            a.map(&:to_s).join(", ")
+                        else a.to_s
+                        end
+                    msg.gsub "%#{i + 1}", a
+                end
+            end
+
+            # Displays the state of the scheduler. It clears existing
+            # information
+            #
+            # @param [Schedulers::State] state the state
+            def display(state)
+                code = erb.result(binding)
+                self.html = code
+            end
+        end
+    end
+end

data/lib/roby/gui/scheduler_view.rhtml

@@ -0,0 +1,53 @@
+<html>
+<head>
+    <link rel="stylesheet" href="file://<%= scheduler_view_css %>" type="text/css" />
+</head>
+
+<body>
+    <section>
+        <title>Called <%= state.called_generators.size %> generators</title>
+        <called_generators>
+        <% state.called_generators.each do |gen| %>
+            <item><%= gen %></item>
+        <% end %>
+        </called_generators>
+    </section>
+
+    <section>
+        <title><%= state.pending_non_executable_tasks.size %> tasks are pending but not executable</title>
+        <pending_non_executable_tasks>
+            <% state.pending_non_executable_tasks.each do |msg, task, args| %>
+                <item><%= task.to_s + ": " + format_msg_string(msg, task, *args) %></item>
+            <% end %>
+        </pending_non_executable_tasks>
+    </section>
+
+    <section>
+        <title><%= state.actions.size %> actions have been performed</title>
+        <actions>
+            <% state.actions.each do |task, description| %>
+                <title><%= task %></title>
+                <descriptions>
+                    <% description.each do |msg, args| %>
+                        <item><%= format_msg_string(msg, task, *args) %></item>
+                    <% end %>
+                </descriptions>
+            <% end %>
+        </actions>
+    </section>
+
+    <section>
+        <title><%= state.non_scheduled_tasks.size %> tasks have been considered for scheduling, but did not get scheduled</title>
+        <non_scheduled_tasks>
+            <% state.non_scheduled_tasks.each do |task, reasons| %>
+                <title><%= task %></title>
+                <reasons>
+                    <% reasons.each do |msg, args| %>
+                        <item><%= format_msg_string(msg, task, *args) %></item>
+                    <% end %>
+                </reasons>
+            <% end %>
+        </non_scheduled_tasks>
+    </section>
+</body>
+</html>