canvas: Indicate runtime state on links

Author: ales-erjavec

Orange/canvas/canvas/items/linkitem.py

@@ -17,6 +17,8 @@
 from .nodeitem import SHADOW_COLOR
 from .utils import stroke_path
 
+from ...scheme import SchemeLink
+
 
 class LinkCurveItem(QGraphicsPathItem):
     """
@@ -117,21 +119,30 @@ class LinkAnchorIndicator(QGraphicsEllipseItem):
     """
     def __init__(self, *args):
         QGraphicsEllipseItem.__init__(self, *args)
-        self.setRect(-3, -3, 6, 6)
+        self.setRect(-3.5, -3.5, 7., 7.)
         self.setPen(QPen(Qt.NoPen))
-        self.normalBrush = QBrush(QColor("#9CACB4"))
-        self.hoverBrush = QBrush(QColor("#7D7D7D"))
-        self.setBrush(self.normalBrush)
         self.__hover = False
+        self.__brush = QBrush(QColor("#9CACB4"))
+        super().setBrush(self.__brush)
 
     def setHoverState(self, state):
         """The hover state is set by the LinkItem.
         """
         self.__hover = state
         if state:
-            self.setBrush(self.hoverBrush)
+            brush = QBrush(self.__brush.color().darker(110))
         else:
-            self.setBrush(self.normalBrush)
+            brush = self.__brush
+        super().setBrush(brush)
+
+    def setBrush(self, brush):
+        brush = QBrush(brush)
+        if self.__brush != brush:
+            self.__brush = brush
+            super().setBrush(brush)
+
+    def brush(self):
+        return QBrush(self.__brush)
 
 
 class LinkItem(QGraphicsObject):
@@ -151,6 +162,17 @@ class LinkItem(QGraphicsObject):
     #: Z value of the item
     Z_VALUE = 0
 
+    #: Runtime link state value
+    #: These are pulled from SchemeLink.State for ease of binding to it's
+    #: state
+    State = SchemeLink.State
+    #: Link is empty; the source node does not have any value on output
+    Empty = SchemeLink.Empty
+    #: Link is active; the source node has a valid value on output
+    Active = SchemeLink.Active
+    #: The link is pending; the sink node is scheduled for update
+    Pending = SchemeLink.Pending
+
     def __init__(self, *args):
         self.__boundingRect = None
         QGraphicsObject.__init__(self, *args)
@@ -179,7 +201,7 @@ def __init__(self, *args):
 
         self.__dynamic = False
         self.__dynamicEnabled = False
-
+        self.__state = LinkItem.Empty
         self.hover = False
 
         self.prepareGeometryChange()
@@ -500,6 +522,32 @@ def isDynamic(self):
         """
         return self.__dynamic
 
+    def setRuntimeState(self, state):
+        """
+        Style the link appropriate to the LinkItem.State
+
+        Parameters
+        ----------
+        state : LinkItem.State
+        """
+        if self.__state != state:
+            self.__state = state
+
+            if state & LinkItem.Active:
+                self.sourceIndicator.setBrush(QBrush(Qt.green))
+            else:
+                self.sourceIndicator.setBrush(QBrush(Qt.gray))
+
+            if state & LinkItem.Pending:
+                self.sinkIndicator.setBrush(QBrush(Qt.yellow))
+            elif state & LinkItem.Active:
+                self.sinkIndicator.setBrush(QBrush(Qt.green))
+            else:
+                self.sinkIndicator.setBrush(QBrush(Qt.gray))
+
+    def runtimeState(self):
+        return self.__state
+
     def __updatePen(self):
         self.prepareGeometryChange()
         self.__boundingRect = None

Orange/canvas/canvas/scene.py

@@ -442,6 +442,9 @@ def add_link(self, scheme_link):
             item.setDynamicEnabled(scheme_link.dynamic_enabled)
             scheme_link.dynamic_enabled_changed.connect(item.setDynamicEnabled)
 
+        item.setRuntimeState(scheme_link.runtime_state())
+        scheme_link.state_changed.connect(item.setRuntimeState)
+
         self.add_link_item(item)
         self.__item_for_link[scheme_link] = item
         return item
@@ -513,7 +516,7 @@ def remove_link(self, scheme_link):
             scheme_link.dynamic_enabled_changed.disconnect(
                 item.setDynamicEnabled
             )
-
+        scheme_link.state_changed.disconnect(item.setRuntimeState)
         self.remove_link_item(item)
 
     def link_items(self):

Orange/canvas/scheme/link.py

@@ -4,6 +4,7 @@
 ===========
 
 """
+import enum
 
 from PyQt4.QtCore import QObject
 from PyQt4.QtCore import pyqtSignal as Signal
@@ -76,6 +77,23 @@ class SchemeLink(QObject):
     #: The link dynamic enabled state has changed.
     dynamic_enabled_changed = Signal(bool)
 
+    #: Runtime link state has changed
+    state_changed = Signal(int)
+
+    class State(enum.IntEnum):
+        """
+        Flags indicating the runtime state of a link
+        """
+        #: A link is empty when it has no value on it
+        Empty = 0
+        #: A link is active when the source node provides a value on output
+        Active = 1
+        #: A link is pending when it's sink node has not yet been notified
+        #: of a change (note that Empty|Pending is a valid state)
+        Pending = 2
+
+    Empty, Active, Pending = State
+
     def __init__(self, source_node, source_channel,
                  sink_node, sink_channel, enabled=True, properties=None,
                  parent=None):
@@ -108,6 +126,7 @@ def __init__(self, source_node, source_channel,
 
         self.__enabled = enabled
         self.__dynamic_enabled = False
+        self.__state = SchemeLink.Empty
         self.__tool_tip = ""
         self.properties = properties or {}
 
@@ -166,6 +185,26 @@ def dynamic_enabled(self):
     dynamic_enabled = Property(bool, fget=dynamic_enabled,
                                fset=set_dynamic_enabled)
 
+    def set_runtime_state(self, state):
+        """
+        Set the link's runtime state.
+
+        Parameters
+        ----------
+        state : SchemeLink.State
+        """
+        if self.__state != state:
+            self.__state = state
+            self.state_changed.emit(state)
+
+    def runtime_state(self):
+        """
+        Returns
+        -------
+        state : SchemeLink.State
+        """
+        return self.__state
+
     def set_tool_tip(self, tool_tip):
         """
         Set the link tool tip.

Orange/canvas/scheme/signalmanager.py

@@ -20,7 +20,7 @@
 from PyQt4.QtCore import pyqtSignal as Signal
 
 
-from .scheme import SchemeNode
+from .scheme import SchemeNode, SchemeLink
 from functools import reduce
 
 log = logging.getLogger(__name__)
@@ -185,6 +185,7 @@ def on_node_added(self, node):
 
     def link_added(self, link):
         # push all current source values to the sink
+        link.set_runtime_state(SchemeLink.Empty)
         if link.enabled:
             log.info("Link added (%s). Scheduling signal data update.", link)
             self._schedule(self.signals_on_link(link))
@@ -196,6 +197,7 @@ def link_removed(self, link):
         # purge all values in sink's queue
         log.info("Link removed (%s). Scheduling signal data purge.", link)
         self.purge_link(link)
+        link.enabled_changed.disconnect(self.link_enabled_changed)
 
     def link_enabled_changed(self, enabled):
         if enabled:
@@ -223,7 +225,15 @@ def link_contents(self, link):
         """
         node, channel = link.source_node, link.source_channel
 
-        return self._node_outputs[node][channel]
+        if node in self._node_outputs:
+            return self._node_outputs[node][channel]
+        else:
+            # if the the node was already removed it's tracked outputs in
+            # _node_outputs are cleared, however the final 'None' signal
+            # deliveries for the link are left in the _input_queue.
+            pending = [sig for sig in self._input_queue
+                       if sig.link is link]
+            return {sig.id: sig.value for sig in pending}
 
     def send(self, node, channel, value, id):
         """
@@ -260,28 +270,20 @@ def _schedule(self, signals):
         """
         self._input_queue.extend(signals)
 
+        for link in {sig.link for sig in signals}:
+            # update the SchemeLink's runtime state flags
+            contents = self.link_contents(link)
+            if any(value is not None for value in contents.values()):
+                state = SchemeLink.Active
+            else:
+                state = SchemeLink.Empty
+            link.set_runtime_state(state | SchemeLink.Pending)
+
         if signals:
             self.updatesPending.emit()
 
         self._update()
 
-    def _update_links(self, source_node=None, source_channel=None,
-                      sink_node=None, sink_channel=None):
-        """
-        Schedule update of all enabled links matching the query.
-
-        See :ref:`Scheme.find_links` for description of parameters.
-
-        """
-        links = self.scheme().find_links(source_node=source_node,
-                                         source_channel=source_channel,
-                                         sink_node=sink_node,
-                                         sink_channel=sink_channel)
-        links = list(filter(is_enabled, links))
-
-        signals = reduce(add, self.signals_on_link, [])
-        self._schedule(signals)
-
     def _update_link(self, link):
         """
         Schedule update of a single link.
@@ -328,7 +330,12 @@ def process_node(self, node):
 
         log.debug("Processing %r, sending %i signals.",
                   node.title, len(signals_in))
+        # Clear the link's pending flag.
+        for link in {sig.link for sig in signals_in}:
+            link.set_runtime_state(link.runtime_state() & ~SchemeLink.Pending)
 
+        assert ({sig.link for sig in self._input_queue}
+                .intersection({sig.link for sig in signals_in}) == set([]))
         self.processingStarted.emit()
         self.processingStarted[SchemeNode].emit(node)
         try:

Orange/canvas/scheme/widgetsscheme.py

@@ -33,7 +33,7 @@
 from PyQt4.QtCore import pyqtSignal as Signal
 
 from .signalmanager import SignalManager, compress_signals, can_enable_dynamic
-from .scheme import Scheme, SchemeNode
+from .scheme import Scheme, SchemeNode, SchemeLink
 from .node import UserMessage
 from ..utils import name_lookup
 from ..resources import icon_loader