use of org.knime.core.ui.node.workflow.NodeContainerUI in project knime-core by knime.
the class WorkflowCoachView method updateInput.
private void updateInput(final ISelection selection) {
if (NodeRecommendationManager.getInstance().getNumLoadedProviders() == 0) {
// if there is at least one enabled triple provider then the statistics might need to be download first
if (NodeRecommendationManager.getInstance().getNodeTripleProviders().stream().anyMatch(ntp -> ntp.isEnabled())) {
if (m_loadState.get() == LoadState.Disposed) {
return;
}
m_loadState.set(LoadState.LoadingNodes);
updateInput("Loading recommendations ...");
// try updating the triple provider that are enabled and require an update
updateTripleProviders(e -> {
m_loadState.set(LoadState.Initizalized);
if (e.isPresent()) {
updateInputNoProvider();
} else {
try {
NodeRecommendationManager.getInstance().loadRecommendations();
if (NodeRecommendationManager.getInstance().getNumLoadedProviders() == 0) {
// if there are still no triple provider, show link
updateInputNoProvider();
} else {
updateInput("Statistics successfully loaded. Select a node...");
}
} catch (Exception e1) {
updateInputNoProvider();
}
}
}, true, false);
} else {
// no triple provider enabled -> needs to be configured
updateInputNoProvider();
return;
}
}
IStructuredSelection structSel = (IStructuredSelection) selection;
if (structSel.size() > 1) {
updateInput("No recommendation for multiple selected nodes.");
return;
}
// retrieve first (and only!) selection:
Iterator<?> selIt = structSel.iterator();
boolean nodeSelected = selIt.hasNext();
NodeContainer nc = null;
if (nodeSelected) {
Object sel = selIt.next();
nodeSelected &= (sel instanceof NodeContainerEditPart);
if (nodeSelected) {
NodeContainerUI uinc = ((NodeContainerEditPart) sel).getNodeContainer();
if (!Wrapper.wraps(uinc, NodeContainer.class)) {
updateInput("Worklfow coach only supports native nodes, so far.\nBut the selected one is of type '" + uinc.getClass().getSimpleName() + "'.");
return;
} else {
nc = Wrapper.unwrapNC(uinc);
nodeSelected &= nc instanceof NativeNodeContainer;
}
}
}
// -> in that case no redraw is required
if (nodeSelected) {
if (m_lastSelection.equals(nc.getNameWithID())) {
return;
} else {
m_lastSelection = nc.getNameWithID();
}
} else {
if (m_lastSelection.equals("no node selected")) {
return;
} else {
m_lastSelection = "no node selected";
}
}
List<NodeRecommendation>[] recommendations;
if (nodeSelected) {
// retrieve node recommendations if exactly one node is selected
recommendations = NodeRecommendationManager.getInstance().getNodeRecommendationFor((NativeNodeContainer) nc);
} else if (nc == null) {
// retrieve node recommendations if no node is selected (most likely the source nodes etc.)
recommendations = NodeRecommendationManager.getInstance().getNodeRecommendationFor();
} else {
Display.getDefault().syncExec(() -> {
m_viewer.setInput("");
m_viewer.refresh();
});
return;
}
if (recommendations == null) {
// something went wrong with loading the node recommendations, show the configure link
updateInputNoProvider();
return;
}
// TODO: cache node recommendations??
int maxSize = 0;
for (List<NodeRecommendation> l : recommendations) {
maxSize = Math.max(maxSize, l.size());
}
List<NodeRecommendation[]> recommendationsJoined = joinRecommendations(recommendations, maxSize);
// remove duplicates from list
Set<String> duplicates = new HashSet<>();
List<NodeRecommendation[]> recommendationsWithoutDups = new ArrayList<>(recommendationsJoined.size());
for (NodeRecommendation[] nrs : recommendationsJoined) {
int idx = getNonNullIdx(nrs);
if (duplicates.add(nrs[idx].toString())) {
recommendationsWithoutDups.add(nrs);
}
}
// update viewer
changeViewerStateTo(ViewerState.RECOMMENDATIONS);
Display.getDefault().syncExec(() -> {
m_viewer.setInput(recommendationsWithoutDups);
m_viewer.refresh();
m_recommendationsAvailable = true;
// scroll to the very top
if (!recommendationsWithoutDups.isEmpty()) {
m_viewer.getTable().setTopIndex(0);
}
});
}
use of org.knime.core.ui.node.workflow.NodeContainerUI in project knime-core by knime.
the class WorkflowContextMenuProvider method buildContextMenu.
/**
* {@inheritDoc}
*/
@Override
public void buildContextMenu(final IMenuManager manager) {
final String FLOW_VAR_PORT_GRP = "Flow Variable Ports";
// add the groups (grouped by separators) in their order first
manager.add(new Separator(IWorkbenchActionConstants.GROUP_APP));
manager.add(new Separator(FLOW_VAR_PORT_GRP));
GEFActionConstants.addStandardActionGroups(manager);
IAction action;
action = m_actionRegistry.getAction("cut");
manager.appendToGroup(GEFActionConstants.GROUP_EDIT, action);
((UpdateAction) action).update();
action = m_actionRegistry.getAction("copy");
manager.appendToGroup(GEFActionConstants.GROUP_EDIT, action);
((UpdateAction) action).update();
action = m_actionRegistry.getAction(PasteActionContextMenu.ID);
manager.appendToGroup(GEFActionConstants.GROUP_EDIT, action);
((UpdateAction) action).update();
action = m_actionRegistry.getAction("undo");
manager.appendToGroup(GEFActionConstants.GROUP_EDIT, action);
((UpdateAction) action).update();
action = m_actionRegistry.getAction("redo");
manager.appendToGroup(GEFActionConstants.GROUP_EDIT, action);
((UpdateAction) action).update();
action = m_actionRegistry.getAction("delete");
manager.appendToGroup(GEFActionConstants.GROUP_EDIT, action);
((UpdateAction) action).update();
// Add (some) available actions from the registry to the context menu
// manager
// openDialog
action = m_actionRegistry.getAction(OpenDialogAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
((AbstractNodeAction) action).update();
// execute
action = m_actionRegistry.getAction(ExecuteAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
((AbstractNodeAction) action).update();
// execute and open first view
action = m_actionRegistry.getAction(ExecuteAndOpenViewAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
((AbstractNodeAction) action).update();
// cancel execution
action = m_actionRegistry.getAction(CancelAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
((AbstractNodeAction) action).update();
// show some menu items on LoopEndNodes only
List parts = m_viewer.getSelectedEditParts();
if (parts.size() == 1) {
EditPart p = (EditPart) parts.get(0);
if (p instanceof NodeContainerEditPart) {
NodeContainerUI container = (NodeContainerUI) ((NodeContainerEditPart) p).getModel();
if (container instanceof SingleNodeContainerUI) {
SingleNodeContainerUI snc = (SingleNodeContainerUI) container;
Wrapper.unwrapOptional(snc, SingleNodeContainer.class).ifPresent(sncImpl -> {
if (sncImpl.isModelCompatibleTo(LoopEndNode.class)) {
// pause loop execution
IAction loopAction;
loopAction = m_actionRegistry.getAction(PauseLoopExecutionAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, loopAction);
((AbstractNodeAction) loopAction).update();
// step loop execution
loopAction = m_actionRegistry.getAction(StepLoopAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, loopAction);
((AbstractNodeAction) loopAction).update();
// resume loop execution
loopAction = m_actionRegistry.getAction(ResumeLoopAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, loopAction);
((AbstractNodeAction) loopAction).update();
}
});
}
}
}
// reset
action = m_actionRegistry.getAction(ResetAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
((AbstractNodeAction) action).update();
// set name and description
action = m_actionRegistry.getAction(SetNodeDescriptionAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
((AbstractNodeAction) action).update();
// add workflow annotation
action = m_actionRegistry.getAction(AddAnnotationAction.ID);
AddAnnotationAction aaa = (AddAnnotationAction) action;
aaa.setLocation(m_lastLocation.x, m_lastLocation.y);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
((AbstractNodeAction) action).update();
// collapse metanodes
action = m_actionRegistry.getAction(CollapseMetaNodeAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
((AbstractNodeAction) action).update();
action = m_actionRegistry.getAction(EncapsulateSubNodeAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
((AbstractNodeAction) action).update();
// insert "select loop" if loop nodes are selected
boolean addSelectLoop = true;
for (Object p : parts) {
if (!(p instanceof NodeContainerEditPart)) {
addSelectLoop = false;
break;
}
NodeContainerUI nc = ((NodeContainerEditPart) p).getNodeContainer();
if (!(nc instanceof SingleNodeContainerUI)) {
addSelectLoop = false;
break;
}
if (!((SingleNodeContainerUI) nc).isMemberOfScope()) {
addSelectLoop = false;
break;
}
}
if (addSelectLoop) {
action = m_actionRegistry.getAction(SelectLoopAction.ID);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
((AbstractNodeAction) action).update();
}
IMenuManager metanodeMenuMgr = null;
IMenuManager subnodeMenuMgr = null;
IMenuManager subnodeViewMgr = null;
// depending on the current selection: add the actions for the port
// views and the node views
// also check whether this node part is a meta-node
// if so offer the "edit meta-node" option
// all these feature are only offered if exactly 1 part is selected
parts = m_viewer.getSelectedEditParts();
// by now, we only support one part...
if (parts.size() == 1) {
EditPart p = (EditPart) parts.get(0);
if (p instanceof WorkflowInPortBarEditPart) {
WorkflowInPortBarEditPart root = (WorkflowInPortBarEditPart) p;
manager.add(new Separator("outPortViews"));
for (Object o : p.getChildren()) {
EditPart child = (EditPart) o;
if (child instanceof WorkflowInPortEditPart && ((WorkflowInPortEditPart) child).isSelected()) {
final WorkflowManager wm = Wrapper.unwrapWFM(((WorkflowPortBar) root.getModel()).getWorkflowManager());
action = new OpenWorkflowPortViewAction(wm, ((WorkflowInPortEditPart) child).getIndex(), wm.getNrInPorts());
manager.appendToGroup("outPortViews", action);
((WorkflowInPortEditPart) child).setSelected(false);
}
}
}
if (p instanceof NodeContainerEditPart) {
NodeContainerUI container = null;
container = (NodeContainerUI) ((NodeContainerEditPart) p).getModel();
if (!(container instanceof WorkflowManagerUI)) {
action = m_actionRegistry.getAction(ToggleFlowVarPortsAction.ID);
manager.appendToGroup(FLOW_VAR_PORT_GRP, action);
((AbstractNodeAction) action).update();
}
// add for node views option if applicable
int numNodeViews = container.getNrViews();
for (int i = 0; i < numNodeViews; i++) {
action = new OpenViewAction(unwrapNC(container), i);
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
}
// add interactive view options
if (container.hasInteractiveView()) {
action = new OpenInteractiveViewAction(unwrapNC(container));
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
} else {
// TODO for subnodes move to submenu?
if (wraps(container, NativeNodeContainer.class)) {
InteractiveWebViewsResult interactiveWebViewsResult = unwrapNC(container).getInteractiveWebViews();
for (int i = 0; i < interactiveWebViewsResult.size(); i++) {
action = new OpenInteractiveWebViewAction(unwrapNC(container), interactiveWebViewsResult.get(i));
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
}
}
}
if (container instanceof WorkflowManagerUI) {
metanodeMenuMgr = getMetaNodeMenuManager(metanodeMenuMgr, manager);
// OPEN META NODE
action = new OpenSubworkflowEditorAction((NodeContainerEditPart) p);
metanodeMenuMgr.appendToGroup(GROUP_METANODE, action);
// EXPAND META NODE
action = m_actionRegistry.getAction(ExpandMetaNodeAction.ID);
metanodeMenuMgr.appendToGroup(GROUP_METANODE, action);
((AbstractNodeAction) action).update();
// RECONFIGURE META NODE
if (parts.size() == 1) {
action = m_actionRegistry.getAction(MetaNodeReconfigureAction.ID);
metanodeMenuMgr.appendToGroup(GROUP_METANODE, action);
((AbstractNodeAction) action).update();
}
// WRAP
action = m_actionRegistry.getAction(ConvertMetaNodeToSubNodeAction.ID);
metanodeMenuMgr.appendToGroup(GROUP_METANODE, action);
((AbstractNodeAction) action).update();
}
// SUBNODE
if (container instanceof SubNodeContainerUI) {
subnodeMenuMgr = getSubNodeMenuManager(subnodeMenuMgr, manager);
// OPEN SUBNODE
action = new OpenSubNodeEditorAction((NodeContainerEditPart) p);
subnodeMenuMgr.appendToGroup(GROUP_SUBNODE, action);
// EXPAND SUBNODE
action = m_actionRegistry.getAction(ExpandSubNodeAction.ID);
subnodeMenuMgr.appendToGroup(GROUP_SUBNODE, action);
((AbstractNodeAction) action).update();
// RECONFIGURE SUBNODE
action = m_actionRegistry.getAction(SubNodeReconfigureAction.ID);
subnodeMenuMgr.appendToGroup(GROUP_SUBNODE, action);
((AbstractNodeAction) action).update();
// UNWRAP
action = m_actionRegistry.getAction(ConvertSubNodeToMetaNodeAction.ID);
subnodeMenuMgr.appendToGroup(GROUP_SUBNODE, action);
((AbstractNodeAction) action).update();
if (wraps(container, SubNodeContainer.class)) {
InteractiveWebViewsResult interactiveWebViewsResult = unwrapNC(container).getInteractiveWebViews();
if (interactiveWebViewsResult.size() > 0) {
subnodeViewMgr = getSingleSubNodeViewsMenuManager(subnodeViewMgr, subnodeMenuMgr);
for (int i = 0; i < interactiveWebViewsResult.size(); i++) {
action = new OpenInteractiveWebViewAction(unwrapNC(container), interactiveWebViewsResult.get(i));
subnodeViewMgr.appendToGroup(GROUP_SUBNODE_VIEWS, action);
}
}
action = new OpenSubnodeWebViewAction(Wrapper.unwrap(container, SubNodeContainer.class));
manager.appendToGroup(IWorkbenchActionConstants.GROUP_APP, action);
}
}
// add port views
manager.add(new Separator("outPortViews"));
int numOutPorts = container.getNrOutPorts();
for (int i = 0; i < numOutPorts; i++) {
if (i == 0 && !(container instanceof WorkflowManagerUI)) {
// skip the implicit flow var ports on "normal" nodes
continue;
}
if (wraps(container, NodeContainer.class)) {
action = new OpenPortViewAction(unwrapNC(container), i, numOutPorts);
manager.appendToGroup("outPortViews", action);
}
}
}
}
boolean addMetaNodeActions = false;
boolean addSubNodeActions = false;
for (Object p : parts) {
if (p instanceof NodeContainerEditPart) {
NodeContainerUI model = ((NodeContainerEditPart) p).getNodeContainer();
if (model instanceof WorkflowManagerUI) {
addMetaNodeActions = true;
} else if (model instanceof SubNodeContainerUI) {
addSubNodeActions = true;
}
}
}
if (addMetaNodeActions) {
metanodeMenuMgr = getMetaNodeMenuManager(metanodeMenuMgr, manager);
// SAVE AS TEMPLATE
action = m_actionRegistry.getAction(SaveAsMetaNodeTemplateAction.ID);
metanodeMenuMgr.appendToGroup(GROUP_METANODE_LINKS, action);
((AbstractNodeAction) action).update();
// CHECK UPDATE
action = m_actionRegistry.getAction(CheckUpdateMetaNodeLinkAction.ID);
metanodeMenuMgr.appendToGroup(GROUP_METANODE_LINKS, action);
((AbstractNodeAction) action).update();
// DISCONNECT
action = m_actionRegistry.getAction(DisconnectMetaNodeLinkAction.ID);
metanodeMenuMgr.appendToGroup(GROUP_METANODE_LINKS, action);
((AbstractNodeAction) action).update();
// LINK TYPE
action = m_actionRegistry.getAction(ChangeMetaNodeLinkAction.ID);
metanodeMenuMgr.appendToGroup(GROUP_METANODE_LINKS, action);
((AbstractNodeAction) action).update();
// REVEAL TEMPLATE
action = m_actionRegistry.getAction(RevealMetaNodeTemplateAction.ID);
metanodeMenuMgr.appendToGroup(GROUP_METANODE_LINKS, action);
((AbstractNodeAction) action).update();
// LOCK
if (Boolean.getBoolean(KNIMEConstants.PROPERTY_SHOW_METANODE_LOCK_ACTION)) {
action = m_actionRegistry.getAction(LockMetaNodeAction.ID);
metanodeMenuMgr.appendToGroup(GROUP_METANODE, action);
((AbstractNodeAction) action).update();
}
}
if (addSubNodeActions) {
subnodeMenuMgr = getSubNodeMenuManager(subnodeMenuMgr, manager);
// SAVE AS TEMPLATE (SUBNODE)
action = m_actionRegistry.getAction(SaveAsSubNodeTemplateAction.ID);
subnodeMenuMgr.appendToGroup(GROUP_SUBNODE_LINKS, action);
((AbstractNodeAction) action).update();
// CHECK UPDATE (SUBNODE)
action = m_actionRegistry.getAction(CheckUpdateMetaNodeLinkAction.ID);
subnodeMenuMgr.appendToGroup(GROUP_SUBNODE_LINKS, action);
((AbstractNodeAction) action).update();
// DISCONNECT LINK (SUBNODE)
action = m_actionRegistry.getAction(DisconnectSubNodeLinkAction.ID);
subnodeMenuMgr.appendToGroup(GROUP_SUBNODE_LINKS, action);
((AbstractNodeAction) action).update();
// CHANGE LINK (SUBNODE)
action = m_actionRegistry.getAction(ChangeSubNodeLinkAction.ID);
subnodeMenuMgr.appendToGroup(GROUP_SUBNODE_LINKS, action);
((AbstractNodeAction) action).update();
// REVEAL TEMPLATE (SUBNODE)
action = m_actionRegistry.getAction(RevealSubNodeTemplateAction.ID);
subnodeMenuMgr.appendToGroup(GROUP_SUBNODE_LINKS, action);
((AbstractNodeAction) action).update();
// LOCK SUBNODE
if (Boolean.getBoolean(KNIMEConstants.PROPERTY_SHOW_METANODE_LOCK_ACTION)) {
action = m_actionRegistry.getAction(LockSubNodeAction.ID);
subnodeMenuMgr.appendToGroup(GROUP_SUBNODE, action);
((AbstractNodeAction) action).update();
}
}
manager.updateAll(true);
}
use of org.knime.core.ui.node.workflow.NodeContainerUI in project knime-core by knime.
the class MetaNodeReconfigureAction method internalCalculateEnabled.
/**
* @return true, if underlying model instance of <code>WorkflowManager</code>, otherwise false
*/
@Override
protected boolean internalCalculateEnabled() {
NodeContainerEditPart[] nodes = getSelectedParts(NodeContainerEditPart.class);
if (nodes.length != 1) {
return false;
}
NodeContainerUI nc = nodes[0].getNodeContainer();
if (nc instanceof WorkflowManagerUI) {
WorkflowManagerUI metaNode = (WorkflowManagerUI) nc;
return !metaNode.isWriteProtected();
}
return false;
}
use of org.knime.core.ui.node.workflow.NodeContainerUI in project knime-core by knime.
the class DefaultOpenViewAction method internalCalculateEnabled.
/**
* @return true if at least one selected node is executing or queued
* @see org.eclipse.gef.ui.actions.WorkbenchPartAction#calculateEnabled()
*/
@Override
protected boolean internalCalculateEnabled() {
NodeContainerEditPart[] parts = getSelectedParts(NodeContainerEditPart.class);
// enable if we have at least one executing or queued node in our
// selection
boolean atLeastOneNodeIsExecuted = false;
for (int i = 0; i < parts.length; i++) {
NodeContainerUI nc = parts[i].getNodeContainer();
boolean hasView = nc.getNrViews() > 0;
if (Wrapper.wraps(nc, NodeContainer.class)) {
hasView |= nc.hasInteractiveView() || unwrapNC(nc).getInteractiveWebViews().size() > 0;
hasView |= OpenSubnodeWebViewAction.hasContainerView(unwrapNC(nc));
atLeastOneNodeIsExecuted |= nc.getNodeContainerState().isExecuted() && hasView;
}
}
return atLeastOneNodeIsExecuted;
}
use of org.knime.core.ui.node.workflow.NodeContainerUI in project knime-core by knime.
the class MoveNodeAbstractAction method createCompoundCommand.
/**
* @param nodeParts selected nodes and connections
* @return compound command of all move commands or null if no edit part is selected
*/
public CompoundCommand createCompoundCommand(final NodeContainerEditPart[] nodeParts) {
List<EditPart> selParts = getMoveableSelectedEditParts();
if (selParts.size() < 1) {
return null;
}
// should be initialized from the pref page
// (0, 1) moves down, (-1, 0) moves left
Point offset = getMoveDirection();
int signX = (int) Math.signum(offset.x);
int signY = (int) Math.signum(offset.y);
CompoundCommand compoundCommand = new CompoundCommand();
if (getEditor().getEditorSnapToGrid()) {
// adjust offset to grid size (note: arguments must be not-negative numbers)
offset = new Point(signX * getEditor().getEditorGridXOffset(signX * offset.x), signY * getEditor().getEditorGridYOffset(signY * offset.y));
if (selParts.size() == 1) {
// with one element we move the element onto the grid if it is off
Point refLoc = null;
if (selParts.get(0) instanceof NodeContainerEditPart) {
NodeContainerEditPart node = (NodeContainerEditPart) selParts.get(0);
NodeContainerFigure figure = (NodeContainerFigure) node.getFigure();
Point iconOffset = SnapIconToGrid.getGridRefPointOffset(figure);
refLoc = new Point(figure.getBounds().x, figure.getBounds().y);
refLoc.translate(iconOffset);
} else {
IFigure fig = ((AbstractWorkflowEditPart) selParts.get(0)).getFigure();
refLoc = new Point(fig.getBounds().x, fig.getBounds().y);
}
Point gridLoc = new Point(0, 0);
Point prevGridLoc = getEditor().getPrevGridLocation(refLoc);
Point nextGridLoc = getEditor().getNextGridLocation(refLoc);
boolean toGrid = false;
if (signX < 0) {
gridLoc.x = prevGridLoc.x;
toGrid = (gridLoc.x != refLoc.x);
}
if (signX > 0) {
gridLoc.x = nextGridLoc.x;
toGrid = (gridLoc.x != refLoc.x);
}
if (signY < 0) {
gridLoc.y = prevGridLoc.y;
toGrid = (gridLoc.y != refLoc.y);
}
if (signY > 0) {
gridLoc.y = nextGridLoc.y;
toGrid = (gridLoc.y != refLoc.y);
}
if (toGrid) {
offset = new Point(Math.abs(gridLoc.x - refLoc.x) * signX, Math.abs(gridLoc.y - refLoc.y) * signY);
}
}
}
int noNodes = 0;
// apply the offset to all selected elements
for (EditPart epart : selParts) {
// apply to selected nodes
if (epart instanceof NodeContainerEditPart) {
NodeContainerEditPart node = (NodeContainerEditPart) epart;
noNodes++;
NodeContainerUI nc = node.getNodeContainer();
NodeContainerFigure figure = (NodeContainerFigure) node.getFigure();
Rectangle bounds = figure.getBounds().getCopy();
bounds.translate(offset);
ChangeNodeBoundsCommand cmd = new ChangeNodeBoundsCommand(Wrapper.unwrapNC(nc), figure, bounds);
compoundCommand.add(cmd);
}
// apply to all selected workflow annotations
if ((epart instanceof AnnotationEditPart) && !(epart instanceof NodeAnnotationEditPart)) {
AnnotationEditPart anno = (AnnotationEditPart) epart;
Rectangle bounds = anno.getFigure().getBounds().getCopy();
bounds.translate(offset);
ChangeAnnotationBoundsCommand cmd = new ChangeAnnotationBoundsCommand(getManager(), anno, bounds);
compoundCommand.add(cmd);
}
}
if (noNodes > 1) {
// if multiple nodes are selected/moved we need to move fully contained connections as well
ConnectionContainerEditPart[] conns = WorkflowSelectionDragEditPartsTracker.getEmbracedConnections(selParts);
for (ConnectionContainerEditPart conn : conns) {
ChangeBendPointLocationCommand connCmd = new ChangeBendPointLocationCommand(conn, offset.getCopy(), null);
compoundCommand.add(connCmd);
}
}
return compoundCommand;
}
Aggregations