use of org.osate.ge.gef.LabelNode in project osate2 by osate.
the class SelectedElementsMover method updateSceneGraph.
/**
* Updates the positions of scene graph nodes.
* @param totalPositionDelta the total movement since the beginning of the interaction.
* @param snapToGrid whether the positions should be snapped to grid. Ignored for connection labels.
*/
public void updateSceneGraph(final Point2D totalPositionDelta, final boolean snapToGrid) {
final Transform sceneToDiagramTransform = editor.getGefDiagram().getSceneNode().getSceneToLocalTransform();
// Reset guide
guides.reset();
// Move nodes
for (final DiagramElementSnapshot snapshot : elementsToMove) {
if (snapshot.sceneNode instanceof LabelNode) {
final BaseConnectionNode cn = InputEventHandlerUtil.getClosestConnection(snapshot.sceneNode);
// Secondary connection label
if (cn != null) {
// Determine the new position in diagram coordinates
final double newPositionX = InputEventHandlerUtil.snapX(editor, snapshot.boundsInDiagram.getMinX() + totalPositionDelta.getX(), false);
final double newPositionY = InputEventHandlerUtil.snapX(editor, snapshot.boundsInDiagram.getMinY() + totalPositionDelta.getY(), false);
// Set the new position relative to the midpoint
final Point2D connectionMidpointPositionInDiagram = sceneToDiagramTransform.transform(cn.getLocalToSceneTransform().transform(cn.getMidpointAnchorPosition()));
PreferredPosition.set(snapshot.sceneNode, new Point2D(newPositionX - connectionMidpointPositionInDiagram.getX(), newPositionY - connectionMidpointPositionInDiagram.getY()));
}
} else {
// Determine snapped position
double newPositionX = snapshot.positionInLocal.getX() + (InputEventHandlerUtil.snapX(editor, snapshot.boundsInDiagram.getMinX() + totalPositionDelta.getX(), snapToGrid) - snapshot.boundsInDiagram.getMinX());
double newPositionY = snapshot.positionInLocal.getY() + (InputEventHandlerUtil.snapY(editor, snapshot.boundsInDiagram.getMinY() + totalPositionDelta.getY(), snapToGrid) - snapshot.boundsInDiagram.getMinY());
// Constrain the position to the container
final Node container = InputEventHandlerUtil.getLogicalShapeContainer(snapshot.sceneNode);
if (container instanceof ContainerShape) {
final Bounds parentBounds = container.getLayoutBounds();
newPositionX = Math.max(0, Math.min(newPositionX, parentBounds.getWidth() - snapshot.boundsInDiagram.getWidth()));
newPositionY = Math.max(0, Math.min(newPositionY, parentBounds.getHeight() - snapshot.boundsInDiagram.getHeight()));
}
// Update guide overlay
if (guides.shouldUpdate()) {
guides.update(sceneToDiagramTransform.transform(snapshot.sceneNode.getLocalToSceneTransform().transform(snapshot.sceneNode.getLayoutBounds())));
}
// Adjust the position and size
final Point2D currentPreferredPosition = PreferredPosition.get(snapshot.sceneNode);
if (currentPreferredPosition == null || currentPreferredPosition.getX() != newPositionX || currentPreferredPosition.getY() != newPositionY) {
PreferredPosition.set(snapshot.sceneNode, new Point2D(newPositionX, newPositionY));
if (showAffectedConnections) {
final double dx = currentPreferredPosition == null ? 0 : (newPositionX - currentPreferredPosition.getX());
final double dy = currentPreferredPosition == null ? 0 : (newPositionY - currentPreferredPosition.getY());
shiftAffectedConnections(snapshot, dx, dy);
}
// Update side for docked shapes
if (snapshot.sceneNode instanceof DockedShape) {
final DockedShape ds = (DockedShape) snapshot.sceneNode;
if (container instanceof ContainerShape) {
final ContainerShape cs = (ContainerShape) container;
final Bounds containerBounds = cs.getLayoutBounds();
final DockSide side = GefAgeDiagramUtil.toDockSide(DockArea.fromDockingPosition(AgeDiagramUtil.determineDockingPosition(containerBounds.getWidth(), containerBounds.getHeight(), newPositionX, newPositionY, snapshot.boundsInDiagram.getWidth(), snapshot.boundsInDiagram.getHeight())));
cs.addOrUpdateDockedChild(ds, side);
}
}
}
}
}
}
use of org.osate.ge.gef.LabelNode in project osate2 by osate.
the class GefAgeDiagram method ensureSceneNodeExists.
/**
* Ensures that a scene node exists for the specified GEF diagram element.
* Creates or recreates scene nodes and adds to the scene graph as necessary. Updates the specified GEF diagram element.
* @param gefDiagramElement the GEF diagram element for which to ensure that the scene node exists.
* @param parentDiagramElementSceneNode the scene node for the parent of the GEF diagram element. This is specified instead of using
* the value contained in the GEF diagram element because it may not be up to date.
* @return the scene node for the diagram element. This specified GEF diagram element will be updated to hold this value.
*/
private Node ensureSceneNodeExists(GefDiagramElement gefDiagramElement, final Node parentDiagramElementSceneNode) {
Objects.requireNonNull(parentDiagramElementSceneNode, "parentDiagramElementScenenNode must not be null");
final Graphic graphic = Objects.requireNonNull(gefDiagramElement.diagramElement.getGraphic(), "graphic must not be null");
final DiagramElement childDiagramElement = gefDiagramElement.diagramElement;
//
// The following final variables determine the operations that needs to be performed by the remainder of the function.
// They are set by comparing the previous state with the current state of the diagram element.
//
final boolean docked = childDiagramElement.getDockArea() != null;
final boolean parentIsConnection = parentDiagramElementSceneNode instanceof BaseConnectionNode;
final boolean create = !Objects.equals(graphic, gefDiagramElement.sourceGraphic) || docked != gefDiagramElement.sceneNode instanceof DockedShape || parentIsConnection != gefDiagramElement.parentDiagramNodeSceneNode instanceof BaseConnectionNode;
final boolean addToScene = create || gefDiagramElement.parentDiagramNodeSceneNode != parentDiagramElementSceneNode;
final boolean removeFromScene = addToScene && gefDiagramElement.sceneNode != null;
// Update other fields
gefDiagramElement.sourceGraphic = graphic;
// Remove the node for the scene graph
if (removeFromScene) {
removeNode(gefDiagramElement.sceneNode);
}
//
if (create) {
// Remove mapping to old scene node
if (gefDiagramElement.sceneNode != null) {
sceneNodeToGefDiagramElementMap.remove(gefDiagramElement.sceneNode);
}
// Create the new node. Create a graphic and then a wrapper as appropriate
final Node graphicNode = GraphicToFx.createNode(graphic);
if (graphicNode instanceof BaseConnectionNode) {
final BaseConnectionNode newConnectionNode = (BaseConnectionNode) graphicNode;
gefDiagramElement.sceneNode = graphicNode;
// Create the primary label node
final LabelNode primaryLabel = new LabelNode();
newConnectionNode.getPrimaryLabels().add(primaryLabel);
gefDiagramElement.primaryLabel = primaryLabel;
} else if (graphicNode instanceof LabelNode) {
gefDiagramElement.sceneNode = graphicNode;
} else if (parentIsConnection) {
// NOTE: This should only occur for fixed sized graphics
// Rotate midpoint decorations 180.0 degrees because our connection not expects midpoint decorations to be oriented as if
// the connection was left to right and that is not how graphics are specified in the graphical editor.
final Group rotationWrapper = new Group();
rotationWrapper.getChildren().add(graphicNode);
rotationWrapper.setRotate(180.0);
gefDiagramElement.sceneNode = rotationWrapper;
} else {
if (docked) {
final DockedShape newDockedShape = new DockedShape();
newDockedShape.setGraphic(graphicNode);
gefDiagramElement.sceneNode = newDockedShape;
// Create the primary label node
final LabelNode primaryLabel = new LabelNode();
newDockedShape.getPrimaryLabels().add(primaryLabel);
gefDiagramElement.primaryLabel = primaryLabel;
// Create annotation node
final LabelNode annotationLabel = new LabelNode();
newDockedShape.getSecondaryLabels().add(annotationLabel);
gefDiagramElement.annotationLabel = annotationLabel;
} else {
final ContainerShape newContainerShape = new ContainerShape();
newContainerShape.setGraphic(graphicNode);
gefDiagramElement.sceneNode = newContainerShape;
// Create the primary label node
final LabelNode primaryLabel = new LabelNode();
newContainerShape.getPrimaryLabels().add(primaryLabel);
gefDiagramElement.primaryLabel = primaryLabel;
}
}
// Add mapping to scene node
if (gefDiagramElement.sceneNode != null) {
sceneNodeToGefDiagramElementMap.put(gefDiagramElement.sceneNode, gefDiagramElement);
}
StyleRoot.set(gefDiagramElement.sceneNode, true);
}
//
if (addToScene) {
if (gefDiagramElement.sceneNode instanceof BaseConnectionNode) {
diagramNode.getChildren().add(gefDiagramElement.sceneNode);
// Flow indicators are positioned relative to the scene node of the parent diagram element
if (gefDiagramElement.sceneNode instanceof FlowIndicatorNode) {
if (parentDiagramElementSceneNode instanceof ContainerShape) {
((FlowIndicatorNode) gefDiagramElement.sceneNode).setPositioningReference(parentDiagramElementSceneNode);
} else {
throw new AgeGefRuntimeException("Unexpected parent diagram element scene node for flow indicator: " + parentDiagramElementSceneNode);
}
}
} else if (gefDiagramElement.sceneNode instanceof LabelNode) {
// Add label to parent
if (parentDiagramElementSceneNode instanceof ContainerShape) {
((ContainerShape) parentDiagramElementSceneNode).getSecondaryLabels().add(gefDiagramElement.sceneNode);
} else if (parentDiagramElementSceneNode instanceof DockedShape) {
((DockedShape) parentDiagramElementSceneNode).getSecondaryLabels().add(gefDiagramElement.sceneNode);
} else if (parentDiagramElementSceneNode instanceof BaseConnectionNode) {
((BaseConnectionNode) parentDiagramElementSceneNode).getSecondaryLabels().add(gefDiagramElement.sceneNode);
} else {
throw new AgeGefRuntimeException("Unexpected parent node for label: " + parentDiagramElementSceneNode);
}
} else if (parentIsConnection) {
((BaseConnectionNode) parentDiagramElementSceneNode).getMidpointDecorations().add(gefDiagramElement.sceneNode);
} else {
final DockArea dockArea = childDiagramElement.getDockArea();
if (gefDiagramElement.sceneNode instanceof DockedShape) {
final DockedShape dockedShape = (DockedShape) gefDiagramElement.sceneNode;
// Add the docked shape to the appropriate list
if (parentDiagramElementSceneNode instanceof ContainerShape) {
final ContainerShape containerShapeParent = (ContainerShape) parentDiagramElementSceneNode;
containerShapeParent.addOrUpdateDockedChild(dockedShape, GefAgeDiagramUtil.toDockSide(dockArea));
} else if (parentDiagramElementSceneNode instanceof DockedShape) {
final DockedShape dockedShapeParent = (DockedShape) parentDiagramElementSceneNode;
dockedShapeParent.getNestedChildren().add(dockedShape);
} else {
throw new AgeGefRuntimeException("Unexpected parent for docked shape: " + parentDiagramElementSceneNode);
}
} else {
if (parentDiagramElementSceneNode instanceof ContainerShape) {
final ContainerShape containerShapeParent = (ContainerShape) parentDiagramElementSceneNode;
containerShapeParent.getFreeChildren().add(gefDiagramElement.sceneNode);
} else if (parentDiagramElementSceneNode instanceof Group) {
((Group) parentDiagramElementSceneNode).getChildren().add(gefDiagramElement.sceneNode);
} else {
throw new AgeGefRuntimeException("Unexpected parent node for container shape: " + parentDiagramElementSceneNode);
}
}
}
gefDiagramElement.parentDiagramNodeSceneNode = parentDiagramElementSceneNode;
}
return gefDiagramElement.sceneNode;
}
use of org.osate.ge.gef.LabelNode in project osate2 by osate.
the class GefAgeDiagram method updateSceneNode.
/**
* Updates the scene nodes related to the specified GEF diagram element based on the diagram element.
* Only updates properties which do not effect the structure of the scene graph. Not-recursive
* @param gefDiagramElement is the GEF diagram element for which scene nodes will be updated.
*/
private void updateSceneNode(final GefDiagramElement gefDiagramElement) {
final DiagramElement diagramElement = gefDiagramElement.diagramElement;
final Node sceneNode = gefDiagramElement.sceneNode;
// Update connections
if (sceneNode instanceof BaseConnectionNode) {
final BaseConnectionNode connectionNode = (BaseConnectionNode) sceneNode;
final Point controlPointOrigin = getControlPointOriginFromDiagram(diagramElement, sceneNode);
if (sceneNode instanceof FlowIndicatorNode) {
PreferredPosition.set(sceneNode, convertPoint(diagramElement.getPosition()));
}
// Update the connection anchor
updateConnectionAnchors(diagramElement, (BaseConnectionNode) sceneNode);
// Set control points. Coordinates are specified in the diagram model relative to the diagram. The need to be specified relative to the
// connection position. For regular connection this is the same because the node's parent is the diagram node.
// However, flow indicators have a position and have parent nodes other than the diagram.
connectionNode.getInnerConnection().setControlPoints(diagramElement.getBendpoints().stream().map(p -> new org.eclipse.gef.geometry.planar.Point(p.x - controlPointOrigin.x, p.y - controlPointOrigin.y)).collect(Collectors.toList()));
PreferredPosition.set(gefDiagramElement.primaryLabel, convertPoint(diagramElement.getConnectionPrimaryLabelPosition()));
} else if (sceneNode instanceof LabelNode) {
// Such a label represents a secondary label
final LabelNode label = (LabelNode) sceneNode;
label.setText(Strings.nullToEmpty(diagramElement.getLabelName()));
setLabelVisibility(label);
// Update element position
if (gefDiagramElement.parentDiagramNodeSceneNode instanceof BaseConnectionNode) {
PreferredPosition.set(label, convertPoint(diagramElement.getPosition()));
}
} else if (sceneNode instanceof ContainerShape) {
final ContainerShape containerShape = (ContainerShape) sceneNode;
PreferredPosition.set(sceneNode, convertPoint(diagramElement.getPosition()));
// Set configured size
final Dimension size = diagramElement.getSize();
if (size == null) {
containerShape.setConfiguredWidth(ContainerShape.NOT_SPECIFIED);
containerShape.setConfiguredHeight(ContainerShape.NOT_SPECIFIED);
} else {
containerShape.setConfiguredWidth(size.width);
containerShape.setConfiguredHeight(size.height);
}
} else if (sceneNode instanceof DockedShape) {
final DockedShape n = (DockedShape) sceneNode;
PreferredPosition.set(sceneNode, convertPoint(diagramElement.getPosition()));
// Set configured size
final Dimension size = diagramElement.getSize();
if (size == null) {
n.setConfiguredWidth(ContainerShape.NOT_SPECIFIED);
n.setConfiguredHeight(ContainerShape.NOT_SPECIFIED);
} else {
n.setConfiguredWidth(size.width);
n.setConfiguredHeight(size.height);
}
final DockArea dockArea = diagramElement.getDockArea();
if (dockArea != null && dockArea != DockArea.GROUP && gefDiagramElement.parentDiagramNodeSceneNode instanceof ContainerShape) {
final DockSide side = GefAgeDiagramUtil.toDockSide(dockArea);
final ContainerShape cs = (ContainerShape) gefDiagramElement.parentDiagramNodeSceneNode;
cs.addOrUpdateDockedChild(n, side);
}
}
// Update the primary label
if (gefDiagramElement.primaryLabel != null) {
gefDiagramElement.primaryLabel.setText(getPrimaryLabelText(diagramElement));
setLabelVisibility(gefDiagramElement.primaryLabel);
gefDiagramElement.primaryLabel.setWrapText(diagramElement.getGraphicalConfiguration().isPrimaryLabelIsMultiline());
}
// Update the secondary label
if (gefDiagramElement.annotationLabel != null) {
final String annotation = diagramElement.getGraphicalConfiguration().getAnnotation();
gefDiagramElement.annotationLabel.setText(Strings.nullToEmpty(annotation));
setLabelVisibility(gefDiagramElement.annotationLabel);
}
}
use of org.osate.ge.gef.LabelNode in project osate2 by osate.
the class RenameInteraction method handleEvent.
@Override
public HandledEvent handleEvent(final InputEvent e) {
// Only handle primary mouse button releases
if (e.getEventType() != MouseEvent.MOUSE_PRESSED && e.getEventType() != MouseEvent.MOUSE_RELEASED) {
return null;
}
final MouseEvent mouseEvent = (MouseEvent) e;
if (mouseEvent.getButton() != MouseButton.PRIMARY) {
return null;
}
final DiagramElement clickedDiagramElement = InputEventHandlerUtil.getTargetDiagramElement(editor.getGefDiagram(), e.getTarget());
if (!editor.getPaletteModel().isSelectToolActive() || clickedDiagramElement == null) {
return null;
}
if (e.getEventType() == MouseEvent.MOUSE_PRESSED) {
wasSelected = editor.getSelectedDiagramElements().contains(clickedDiagramElement);
mousePressDiagramElement = clickedDiagramElement;
} else if (e.getEventType() == MouseEvent.MOUSE_RELEASED && mouseEvent.getButton() == MouseButton.PRIMARY && !mouseEvent.isShiftDown() && !mouseEvent.isControlDown() && wasSelected && clickedDiagramElement == mousePressDiagramElement && editor.getSelectedDiagramElements().contains(clickedDiagramElement)) {
final LabelNode primaryLabel = editor.getGefDiagram().getPrimaryLabelSceneNode(clickedDiagramElement);
if (isAncestor(primaryLabel, (Node) e.getTarget()) && EditorRenameUtil.canRename(clickedDiagramElement)) {
final RenameInteraction newInteraction = new RenameInteraction(clickedDiagramElement, primaryLabel, editor);
return HandledEvent.newInteraction(newInteraction);
}
return HandledEvent.consumed();
}
return null;
}
use of org.osate.ge.gef.LabelNode in project osate2 by osate.
the class UiTestUtil method renameElementDirectEdit.
/**
* Renames the specified element executing direct edit on the diagram elements label.
*/
public static void renameElementDirectEdit(final DiagramReference diagram, final DiagramElementReference element, final String newName, final String expectedNewLabel) {
selectDiagramElements(diagram, element);
// Get the editor
final AgeEditor editor = getDiagramEditor(diagram);
final DiagramElement de = getDiagramElement(diagram, element).orElseThrow(() -> new RuntimeException("Cannot find diagram element for '" + element + "'."));
// Find the primary label
final LabelNode primaryLabel = editor.getGefDiagram().getPrimaryLabelSceneNode(de);
// Find the scene node for the primary label
assertNotNull("Unable to find primary label", primaryLabel);
// Reveal and click the primary label
Display.getDefault().syncExec(() -> editor.reveal(primaryLabel));
fxBot.firePressAndReleasePrimaryMouseButtonEvents(primaryLabel);
waitUntil(() -> UIThreadRunnable.syncExec(() -> editor.getFxCanvas().getScene().getFocusOwner() instanceof TextField), "edit field does not have focus.");
final Node eventTarget = UIThreadRunnable.syncExec(() -> editor.getFxCanvas().getScene().getFocusOwner());
// Type to edit text
fxBot.type(eventTarget, newName);
// Press enter to finish
fxBot.pressAndReleaseEnterKey(eventTarget);
// Wait until the label changes to the expected value
waitUntil(() -> UIThreadRunnable.syncExec(() -> Objects.equals(primaryLabel.getText(), expectedNewLabel)), "primary label does not have expected value after rename");
}
Aggregations