Connect up animation of force derived layouts.

Author: hsorby

src/mapclient/core/managers/workflowmanager.py

@@ -216,7 +216,7 @@ def layout_workflow(self, layout_algorithm):
             raise WorkflowError(f"Unknown layout algorithm: {layout_algorithm}")
 
         self._iteration_count = 0
-        animate = False
+        animate = True
         if animate:
             self._layout_timer.start(16)
         else:

src/mapclient/core/workflow/workflowdependencygraph.py

@@ -33,9 +33,9 @@
 
 def _node_is_destination(graph, node):
     """
-    Determine whether or not the given node features
+    Determine whether the given node features
     in a destination of another node.  Return True if
-    the node is a destination, False otherwise..
+    the node is a destination, False otherwise.
     """
     for graph_node in graph:
         if node in graph[graph_node]:
@@ -86,7 +86,7 @@ def _determine_topological_order(graph, starting_set):
 
 def _reverse_dict_with_lists(in_dict):
     reverseDictOut = {}
-    for k, v in list(in_dict.items()):
+    for k, v in in_dict.items():
         for rk in v:
             reverseDictOut[rk] = reverseDictOut.get(rk, [])
             reverseDictOut[rk].append(k)
@@ -98,7 +98,6 @@ class WorkflowDependencyGraph(object):
 
     def __init__(self, scene):
         self._scene = scene
-        self._dependency_graph = {}
         self._reverse_dependency_graph = {}
         self._topological_order = []
         self._current = -1
@@ -122,12 +121,16 @@ def _find_all_connected_nodes(self):
 
     def _calculate_dependency_graph(self):
         graph = {}
-        for item in list(self._scene.items()):
+        graph_ports = []
+        for item in self._scene.items():
             if item.Type == Connection.Type:
                 graph[item.source()] = graph.get(item.source(), [])
                 graph[item.source()].append(item.destination())
-
-        return graph
+                graph_ports.append(
+                    {'from': item.source(), 'from_port': item.sourceIndex(),
+                     'to': item.destination(), 'to_port': item.destinationIndex()}
+                )
+        return graph, graph_ports
 
     def _solo_node(self):
         scene_items = list(self._scene.items())
@@ -153,31 +156,36 @@ def set_finished_callback(self, callback):
     def execute_status_message(self):
         return self._execute_status_message
 
-    def can_execute(self):
-        self._dependency_graph = self._calculate_dependency_graph()
-        self._reverse_dependency_graph = _reverse_dict_with_lists(self._dependency_graph)
+    def graph(self):
+        dependency_graph, graph_ports = self._calculate_dependency_graph()
+        return dependency_graph, graph_ports, _reverse_dict_with_lists(dependency_graph)
+
+    def _determine_graph(self):
+        dependency_graph, _ = self._calculate_dependency_graph()
+        self._reverse_dependency_graph = _reverse_dict_with_lists(dependency_graph)
         # Find all connected nodes in the graph
         nodes = self._find_all_connected_nodes()
         # Find starting point set, uses helper graph
-        starting_set = _find_starting_set(self._dependency_graph, nodes)
+        starting_set = _find_starting_set(dependency_graph, nodes)
 
-        self._topological_order = _determine_topological_order(self._dependency_graph, starting_set)
+        self._topological_order = _determine_topological_order(dependency_graph, starting_set)
 
-        items_count = len(self._scene.items())
         solo_node = self._solo_node()
         if solo_node:
-            self._dependency_graph = {solo_node: []}
             self._topological_order = [solo_node]
 
+    def can_execute(self):
+        self._determine_graph()
         configured = [metastep.getStep().isConfigured() for metastep in self._topological_order]
 
+        items_count = len(self._scene.items())
         if not all(configured):
             self._execute_status_message = "Not all steps are configured."
             return 1
         elif items_count == 0:
             self._execute_status_message = "No steps in workflow."
             return 2
-        elif items_count > 1 and len(self._topological_order) == 0 and len(self._dependency_graph.keys()) == 0:
+        elif items_count > 1 and len(self._topological_order) == 0 and len(self._reverse_dependency_graph.keys()) == 0:
             self._execute_status_message = "Multiple steps but no connections to create workflow."
             return 3
         elif self._current != -1:
@@ -223,8 +231,8 @@ def execute(self):
                     # But don't use this as it is not what is documented.
                     # source_step = connection.source()._step
                     # destination_step = current_node._step
-                    # source_ports = [port for port in source_step._ports if port.has_provides()]
-                    # destination_ports = [port for port in destination_step._ports if port.has_uses()]
+                    # source_ports = [port for port in source_step._ports if port.hasProvides()]
+                    # destination_ports = [port for port in destination_step._ports if port.hasUses()]
                     # source_data_index = source_ports.index(source_step._ports[connection.sourceIndex()])
                     # destination_data_index = destination_ports.index(destination_step._ports[connection.destinationIndex()])
 

src/mapclient/core/workflow/workflowitems.py

@@ -53,6 +53,13 @@ def setPos(self, pos):
     def getStep(self):
         return self._step
 
+    def set_graphics_pos(self, pos):
+        raise NotImplementedError("Implemented only when a graphics item is created.")
+
+    def update_position(self, pos):
+        self.setPos(pos)
+        self.set_graphics_pos(pos)
+
     def getName(self):
         return self._step.getName()
 

src/mapclient/core/workflow/workflowscene.py

@@ -213,6 +213,21 @@ def changeIdentifier(self, meta_step):
             self._manager.changeIdentifier(meta_step.getIdentifier(), meta_step.getStepIdentifier())
         meta_step.syncIdentifier()
 
+    def step_positions(self):
+        positions = []
+        for item in self._items:
+            if item.Type == MetaStep.Type:
+                positions.append(item.getPos())
+
+        return positions
+
+    def set_step_positions(self, positions):
+        for item in self._items:
+            if item.Type == MetaStep.Type:
+                step_identifier = item.getIdentifier()
+                if step_identifier in positions:
+                    item.update_position(positions[step_identifier])
+
     def saveState(self, ws):
         connectionMap = {}
         stepList = []
@@ -382,6 +397,9 @@ def load_state(self, ws, scene_rect):
     def setMainWindow(self, main_window):
         self._main_window = main_window
 
+    def graph(self):
+        return self._dependency_graph.graph()
+
     def canExecute(self):
         return self._dependency_graph.can_execute()
 

src/mapclient/view/mainwindow.py

@@ -317,6 +317,9 @@ def abort_execution(self):
     def set_workflow_direction(self, direction):
         self.model().workflowManager().set_workflow_direction(direction)
 
+    def layout_workflow(self, layout_algorithm):
+        self.model().workflowManager().layout_workflow(layout_algorithm)
+
     @set_wait_cursor
     def set_current_widget(self, widget):
         if self._ui.stackedWidget.indexOf(widget) <= 0:

src/mapclient/view/workflow/workflowgraphicsitems.py

@@ -258,6 +258,8 @@ def __init__(self, metastep):
 
         self._margin = 2.0
         self._metastep = metastep
+        self._metastep.set_graphics_pos = self.set_graphics_pos
+
         icon = self._metastep.getStep().getIcon()
         if not icon:
             icon = QtGui.QImage(':/workflow/images/default_step_icon.png')
@@ -395,6 +397,9 @@ def setPos(self, pos, modify_parameterised=True):
             self._parameterised_pos = convert_to_parameterised_position(scene.sceneRect(), pos, self.offset())
         self._metastep.setPos(pos)
 
+    def set_graphics_pos(self, pos):
+        self.setPos(pos)
+
     def set_parameterised_pos(self, parameterised_pos):
         self._parameterised_pos = parameterised_pos