public Element selectedNodeElement() { if (selectedNodeId() != null) { return CanvasLayoutUtils.getElement(canvasHandler, selectedNodeId()); } else { return null; } }
private double[] getBoundCoordinates(final Node<View<?>, Edge> node) { if (GraphUtils.isDockedNode(node)) { final Node parent = GraphUtils.getDockParent(node).get(); final Point2D parentPosition = GraphUtils.getPosition((View) parent.getContent()); return getBoundCoordinates(node.getContent(), Optional.ofNullable(parentPosition)); } return getBoundCoordinates(node.getContent(), Optional.empty()); }
private CanvasCommand<AbstractCanvasHandler> updateNodeLocation(final AbstractCanvasHandler canvasHandler, final Node<View<?>, Edge> sourceNode, final Node<View<?>, Edge> targetNode) { // Obtain the candidate locations for the target node. final Point2D location = canvasLayoutUtils.getNext(canvasHandler, sourceNode, targetNode); return canvasCommandFactory.updatePosition(targetNode, location); }
Point2D newPositionUL = getNextPositionWithOffset(rootNodeCoordinates, offset); if (!(isCanvasRoot(canvasHandler.getDiagram(), parentNode.getUUID()))) { checkParent = true; if (isOutOfCanvas(newPositionUL, newNodeHeight, canvasHeight) || checkParent) { newPositionUL = getNextPositionFromParent(rootNodeCoordinates, offset, parentNode, while (((!isCanvasPositionAvailable(graphBoundsIndexer, newPositionUL, newNodeWidth, (newPositionUL.getY() < canvasHeight) && (newPositionUL.getX() < canvasWidth) || isOutOfCanvas(newPositionUL, newNodeHeight, canvasHeight)) { if (!(isCanvasRoot(canvasHandler.getDiagram(), parentNode.getUUID()))) { checkParent = true;
@Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { final String ssid = canvasHandler.getDiagram().getMetadata().getShapeSetId(); final Node<View<?>, Edge> sourceNode = (Node<View<?>, Edge>) CanvasLayoutUtils.getElement(canvasHandler, uuid).asNode(); //deselect node to be morphed, to avoid showing toolbar while morphing clearSelectionEventEvent.fire(new CanvasClearSelectionEvent(canvasHandler)); //delay is used to overcome the toolbar animation while morphing the node final CommandResult<CanvasViolation> result = sessionCommandManager.execute(canvasHandler, commandFactory.morphNode(sourceNode, morphDefinition, targetDefinitionId, ssid)); if (CommandUtils.isError(result)) { LOGGER.log(Level.SEVERE, result.toString()); } else { CanvasLayoutUtils.fireElementSelectedEvent(selectionEvent, canvasHandler, uuid); } return this; }
final Node<View<?>, Edge> root, final Node<View<?>, Edge> newNode) { final double[] rootBounds = getBoundCoordinates(root); final double[] rootSize = GraphUtils.getNodeSize(root.getContent()); final double[] newNodeSize = GraphUtils.getNodeSize(newNode.getContent()); rootBounds[1]); return getNext(canvasHandler, root, rootSize[0],
public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); }
private Point2D getNextPositionFromParent(final Point2D rootNodeCoordinates, final Point2D offset, final Element parentNode, final double rootNodeHeight, final double rootNodeWidth, final double nodeWidth) { final Point2D nextPosition = getNextPositionWithOffset(rootNodeCoordinates, offset); final double[] parentNodeSize = GraphUtils.getNodeSize((View) parentNode.getContent()); final Point2D parentPosition = GraphUtils.getPosition((View) parentNode.getContent()); double newPositionToCheckX = (rootNodeCoordinates.getX() + rootNodeWidth + PADDING_X + nodeWidth); double parentPositionToCheckX = parentNodeSize[0] + parentPosition.getX(); if (newPositionToCheckX > parentPositionToCheckX) { nextPosition.setX(parentPosition.getX() + PADDING_X); nextPosition.setY(rootNodeCoordinates.getY() + rootNodeHeight + PADDING_Y + offset.getY()); } return nextPosition; }
final Element<View<?>> element = (Element<View<?>>) CanvasLayoutUtils.getElement(canvasHandler, sourceNodeId); final Node<View<?>, Edge> sourceNode = element.asNode(); CanvasLayoutUtils.fireElementSelectedEvent(selectionEvent, canvasHandler, targetNode.getUUID());
public boolean isCanvasRoot(final Element parent) { return CanvasLayoutUtils.isCanvasRoot(getDiagram(), parent); }
void onCanvasSelectionEvent(@Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (!Objects.isNull(getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { final String uuid = event.getIdentifiers().iterator().next(); final Element<? extends Definition<?>> element = CanvasLayoutUtils.getElement(getCanvasHandler(), uuid); render(element); } } }
protected boolean isCanvasRoot(final String pUUID) { return CanvasLayoutUtils.isCanvasRoot(getDiagram(), pUUID); }
@Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { if (confirmDelete.test(this)) { final Node<?, Edge> node = CanvasLayoutUtils.getElement(canvasHandler, uuid).asNode(); clearSelectionEvent.fire(new CanvasClearSelectionEvent(canvasHandler)); sessionCommandManager.execute(canvasHandler, commandFactory.deleteNode(node)); } return this; } }
public void applyLayout(final Diagram diagram) { final Graph<?, Node> graph = diagram.getGraph(); if (graph != null && !this.layoutService.hasLayoutInformation(graph)) { final Layout layout = this.layoutService.createLayout(graph); this.layoutExecutor.applyLayout(layout, graph); for (final Node node : graph.nodes()) { if (CanvasLayoutUtils.isCanvasRoot(diagram, node)) { if (node.getContent() instanceof HasBounds) { ((HasBounds) node.getContent()).setBounds(Bounds.create(0, 0, 0, 0)); } } } } } }
void onRefreshFormPropertiesEvent(@Observes RefreshFormPropertiesEvent event) { checkNotNull("event", event); if (!Objects.isNull(getCanvasHandler())) { final String uuid = event.getUuid(); final Element<? extends Definition<?>> element = CanvasLayoutUtils.getElement(getCanvasHandler(), uuid); render(element); } }
@Override public Optional<Object> getSelectedItemDefinition() { String selectedItemUUID = null; final Collection<String> selectedItems = getSelectedItems(); if (null != selectedItems && !selectedItems.isEmpty()) { selectedItemUUID = selectedItems.iterator().next(); } if (Objects.isNull(selectedItemUUID)) { final AbstractCanvasHandler canvasHandler = getCanvasHandler(); if (!Objects.isNull(canvasHandler)) { final Diagram<?, ?> diagram = getCanvasHandler().getDiagram(); if (!Objects.isNull(diagram)) { final String cRoot = diagram.getMetadata().getCanvasRootUUID(); // Check if there exist any canvas root element. if (!StringUtils.isEmpty(cRoot)) { selectedItemUUID = cRoot; } } } } if (!Objects.isNull(selectedItemUUID)) { final Element<? extends Definition<?>> element = CanvasLayoutUtils.getElement(getCanvasHandler(), selectedItemUUID); return Optional.ofNullable(element); } else { return Optional.empty(); } }
@Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { // Notice the toolbox factory ensure this action is only being included // for Decision definitions, next cast is safe. final Node<View<? extends Decision>, Edge> decisionNode = (Node<View<? extends Decision>, Edge>) CanvasLayoutUtils.getElement(canvasHandler, uuid) .asNode(); final Decision decision = decisionNode.getContent().getDefinition(); editExpressionEvent.fire(new EditExpressionEvent(sessionManager.getCurrentSession(), uuid, decision, Optional.of(decision))); return this; } }
@Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { // Notice the toolbox factory ensure this action is only being included // for BusinessKnowledgeModel definitions, next cast is safe. final Node<View<? extends BusinessKnowledgeModel>, Edge> bkmNode = (Node<View<? extends BusinessKnowledgeModel>, Edge>) CanvasLayoutUtils.getElement(canvasHandler, uuid) .asNode(); final BusinessKnowledgeModel bkm = bkmNode.getContent().getDefinition(); editExpressionEvent.fire(new EditExpressionEvent(sessionManager.getCurrentSession(), uuid, bkm.asHasExpression(), Optional.of(bkm))); return this; } }
@Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { // Obtain the connector and source node instances for proxying. final Element<?> element = CanvasLayoutUtils.getElement(canvasHandler, uuid); final Node<View<?>, Edge> sourceNode = (Node<View<?>, Edge>) element.asNode(); final Edge<? extends ViewConnector<?>, Node> connector = (Edge<? extends ViewConnector<?>, Node>) clientFactoryManager .newElement(UUID.uuid(), edgeId) .asEdge(); // Set the transient connection to the source node, for further rule evaluations. connector.setSourceNode(sourceNode); // Built and show a connector drag proxy, to check and finally set // candidate the target node. final double x = event.getX(); final double y = event.getY(); dragProxy = showDragProxy(canvasHandler, connector, sourceNode, (int) x, (int) y); return this; }
@Override public void executeAction(final AbstractCanvasHandler canvasHandler, final String selectedNodeId) { final Node sourceNode = CanvasLayoutUtils.getElement(canvasHandler, selectedNodeId).asNode(); final String definitionSetId = canvasHandler.getDiagram().getMetadata().getDefinitionSetId(); final CommonDomainLookups commonDomainLookups = toolboxDomainLookups.get(definitionSetId); final Set<String> connectorDefinitionIds = commonDomainLookups.lookupTargetConnectors(sourceNode); for (final String connectorDefinitionId : connectorDefinitionIds) { final Set<String> targetNodesDefinitionIds = commonDomainLookups.lookupTargetNodes(canvasHandler.getDiagram().getGraph(), sourceNode, connectorDefinitionId); for (final String targetNodeDefinitionId : targetNodesDefinitionIds) { final Object definition = definitionsCacheRegistry.getDefinitionById(targetNodeDefinitionId); if (canAppendNodeOfDefinition(definition)) { generalCreateNodeAction.executeAction(canvasHandler, selectedNodeId, targetNodeDefinitionId, connectorDefinitionId); break; } } } }