How to use

ChildrenTraverseProcessor

in

org.kie.workbench.common.stunner.core.graph.processing.traverse.content

@SuppressWarnings("unchecked")
public Node<View<?>, Edge> findElementAt(final double x,
                     final double y) {
  final Node[] result = new Node[1];
  childrenTraverseProcessor.traverse(graph,
                    new GraphBoundIndexerTraverseCallback(new NodeBoundsTraverseCallback() {
                      @Override
                      public void onNodeTraverse(final Node<View, Edge> node,
                                   final double parentX,
                                   final double parentY) {
                        if (isNodeAt(node,
                              parentX,
                              parentY,
                              x,
                              y)) {
                          result[0] = node;
                        }
                      }
                    }));
  return result[0];
}

final double[] result = new double[]{Double.MAX_VALUE, Double.MAX_VALUE, 0, 0};
childrenTraverseProcessor
    .setRootUUID(this.rootUUID)
    .traverse(graph,
         new GraphBoundIndexerTraverseCallback(new NodeBoundsTraverseCallback() {

private void traverseChildrenEdges(final Graph<org.kie.workbench.common.stunner.core.graph.content.view.View, Node<org.kie.workbench.common.stunner.core.graph.content.view.View, Edge>> graph,
                  final boolean expand) {
  assert graph != null;
  clear();
  childrenTraverseProcessor.traverse(graph,
                    new AbstractChildrenTraverseCallback<Node<org.kie.workbench.common.stunner.core.graph.content.view.View, Edge>, Edge<Child, Node>>() {
                      @Override
                      public boolean startNodeTraversal(final List<Node<org.kie.workbench.common.stunner.core.graph.content.view.View, Edge>> parents,
                                       final Node<org.kie.workbench.common.stunner.core.graph.content.view.View, Edge> node) {
                        super.startNodeTraversal(parents,
                                    node);
                        addItem(parents.get(parents.size() - 1),
                            node,
                            expand,
                            false);
                        return true;
                      }
                      @Override
                      public void startNodeTraversal(final Node<org.kie.workbench.common.stunner.core.graph.content.view.View, Edge> node) {
                        super.startNodeTraversal(node);
                        addItem(node,
                            expand,
                            false);
                      }
                    });
}

processedConnectors.clear();
childrenTraverseProcessor
    .setRootUUID(candidate.getUUID())
    .traverse(graph,
         new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() {

public List<DecisionNavigatorItem> getItems(final Graph graph) {
  final TraverseCallback traverseCallback = makeTraverseCallback();
  traverseProcessor.traverse(graph, traverseCallback);
  return traverseCallback.getItems();
}

childrenTraverseProcessor.get().setRootUUID(candidate.getUUID()).traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() {
  @Override
  public boolean startNodeTraversal(final List<Node<View, Edge>> parents,

@Test
@SuppressWarnings("unchecked")
public void testShow() {
  testedTree.show(canvasHandler);
  verify(view,
      times(1)).init(eq(testedTree));
  verify(childrenTraverseProcessor,
      times(1)).traverse(eq(graph),
               any(AbstractChildrenTraverseCallback.class));
}

if (hasChildren) {
  childrenTraverseProcessor
      .setRootUUID(element.getUUID())
      .traverse(canvasHandler.getDiagram().getGraph(),
           new AbstractChildrenTraverseCallback<Node<org.kie.workbench.common.stunner.core.graph.content.view.View, Edge>, Edge<Child, Node>>() {

@Test
@SuppressWarnings("unchecked")
public void testTraverseGraph1() {
  final TestingGraphInstanceBuilder.TestGraph1 result =
      TestingGraphInstanceBuilder.newGraph1(graphTestHandler);
  tested.traverse(result.graph,
          callback);
  verify(callback,
      times(1)).startNodeTraversal(eq(result.startNode));
  verify(callback,
      times(1)).startNodeTraversal(eq(result.intermNode));
  verify(callback,
      times(1)).startNodeTraversal(eq(result.endNode));
}

.setRootUUID(getCandidate().getUUID())
.traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() {
  @Override
  public boolean startNodeTraversal(List<Node<View, Edge>> parents, Node<View, Edge> node) {

@Test
@SuppressWarnings("unchecked")
public void testShowWithSingleNodeWithNameAndWithNoTitle() {
  when(graph.nodes()).thenReturn(getMockNodes("node1"));
  when(textPropertyProvider.supports(any(Element.class))).thenReturn(true);
  when(textPropertyProvider.getText(any(Element.class))).thenReturn("my-name");
  testedTree.show(canvasHandler);
  verify(childrenTraverseProcessor,
      times(1)).traverse(eq(graph),
               any(AbstractChildrenTraverseCallback.class));
  verify(view).addItem(eq("node1"),
             eq("my-name"),
             any(IsWidget.class),
             anyBoolean(),
             anyBoolean());
}

@Test
@SuppressWarnings("unchecked")
public void testShowWithSingleNodeWithNoNameAndWithNoTitle() {
  when(graph.nodes()).thenReturn(getMockNodes("node1"));
  testedTree.show(canvasHandler);
  verify(childrenTraverseProcessor,
      times(1)).traverse(eq(graph),
               any(AbstractChildrenTraverseCallback.class));
  verify(view).addItem(eq("node1"),
             eq(TreeExplorer.NO_NAME),
             any(IsWidget.class),
             anyBoolean(),
             anyBoolean());
}

@Test
@SuppressWarnings("unchecked")
public void testShowWithSingleNodeWithNoNameAndWithTitle() {
  when(graph.nodes()).thenReturn(getMockNodes("node1"));
  when(definitionAdapter.getTitle(anyObject())).thenReturn("my-title");
  testedTree.show(canvasHandler);
  verify(childrenTraverseProcessor,
      times(1)).traverse(eq(graph),
               any(AbstractChildrenTraverseCallback.class));
  verify(view).addItem(eq("node1"),
             eq("my-title"),
             any(IsWidget.class),
             anyBoolean(),
             anyBoolean());
}

@SuppressWarnings("unchecked")
public static void moveViewConnectorsToTop(final AbstractCanvasHandler canvasHandler,
                      final Node<?, Edge> node) {
  final Set<String> connectorIds = new HashSet<>();
  // Obtain all view connectors for the node and its children.
  appendViewConnectorIds(connectorIds,
              node);
  new ChildrenTraverseProcessorImpl(new TreeWalkTraverseProcessorImpl())
      .setRootUUID(node.getUUID())
      .traverse(canvasHandler.getGraphIndex().getGraph(),
           new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() {
             @Override
             public boolean startNodeTraversal(final List<Node<View, Edge>> parents,
                              final Node<View, Edge> childNode) {
               appendViewConnectorIds(connectorIds,
                           childNode);
               return true;
             }
           });
  // Update connector's view.
  connectorIds.forEach(id -> moveShapeToTop(canvasHandler,
                       id));
}

final ArgumentCaptor<List> cIntermNodeParents = ArgumentCaptor.forClass(List.class);
final ArgumentCaptor<List> cEndNodeParents = ArgumentCaptor.forClass(List.class);
tested.traverse(result.graph,
        callback);
verify(callback,

.traverse(diagram.getGraph(),
     new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() {

.traverse(graph,
     new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() {
       private Map<String, Boolean> processedNodes = new HashMap<>();