Examples with ConnectionContainerEditPart org.knime.workbench.editor2.editparts.ConnectionContainerEditPart used on opensource projects

Example 11 with ConnectionContainerEditPart

use of org.knime.workbench.editor2.editparts.ConnectionContainerEditPart in project knime-core by knime.

the class WorkflowSelectionDragEditPartsTracker method getOutportConnections.

@SuppressWarnings("unchecked")
private static ConnectionContainerEditPart[] getOutportConnections(final EditPart containerPart) {
    // result list
    List<ConnectionContainerEditPart> result = new ArrayList<ConnectionContainerEditPart>();
    List<EditPart> children = containerPart.getChildren();
    for (EditPart part : children) {
        if (part instanceof AbstractPortEditPart) {
            AbstractPortEditPart outPortPart = (AbstractPortEditPart) part;
            // append all connection edit parts
            result.addAll(outPortPart.getSourceConnections());
        }
    }
    return result.toArray(new ConnectionContainerEditPart[result.size()]);
}

Example 12 with ConnectionContainerEditPart

use of org.knime.workbench.editor2.editparts.ConnectionContainerEditPart in project knime-core by knime.

the class WorkflowEditPartFactory method createEditPart.

/**
 * Creates the referring edit parts for the following parts of the model.
 * <ul>
 * <li>{@link WorkflowManager}: either {@link WorkflowRootEditPart} or {@link NodeContainerEditPart} (depending on
 * the currently displayed level)</li>
 * <li>{@link SingleNodeContainer}: {@link NodeContainerEditPart}</li>
 * <li>{@link NodeInPort}: {@link NodeInPortEditPart}</li>
 * <li>{@link NodeOutPort}: {@link NodeOutPortEditPart}</li>
 * <li>{@link ConnectionContainer}: {@link ConnectionContainerEditPart}</li>
 * <li>{@link WorkflowInPort}: {@link WorkflowInPortEditPart}</li>
 * <li>{@link WorkflowOutPort}: {@link WorkflowOutPortEditPart}</li>
 * </ul>
 *
 * The {@link WorkflowRootEditPart} has its {@link NodeContainer}s and its {@link WorkflowInPort}s and
 * {@link WorkflowOutPort}s as model children. The {@link NodeContainerEditPart} has its {@link NodePort}s as its
 * children.
 *
 * @see WorkflowRootEditPart#getModelChildren()
 * @see NodeContainerEditPart#getModelChildren()
 *
 * @throws IllegalArgumentException if any other object is passed
 *
 *             {@inheritDoc}
 */
@Override
public EditPart createEditPart(final EditPart context, final Object model) {
    // instantiated here
    // correct type in the if statement
    // model at the end of method
    EditPart part = null;
    if (model instanceof WorkflowManagerUI) {
        // this is out "root" workflow manager
        if (m_isTop) {
            // all following objects of type WorkflowManager are treated as
            // metanodes and displayed as NodeContainers
            m_isTop = false;
            part = new WorkflowRootEditPart();
        } else {
            // we already have a "root" workflow manager
            // must be a metanode
            part = new SubworkflowEditPart();
        }
    } else if (model instanceof NodeAnnotation) {
        /* IMPORTANT: first test NodeAnnotation then Annotation (as the
             * first derives from the latter! */
        part = new NodeAnnotationEditPart();
    } else if (model instanceof Annotation) {
        /* IMPORTANT: first test NodeAnnotation then Annotation (as the
             * first derives from the latter! */
        /* workflow annotations hang off the workflow manager */
        part = new AnnotationEditPart();
    } else if (model instanceof WorkflowPortBar) {
        WorkflowPortBar bar = (WorkflowPortBar) model;
        if (bar.isInPortBar()) {
            part = new WorkflowInPortBarEditPart();
        } else {
            part = new WorkflowOutPortBarEditPart();
        }
    } else if (model instanceof SingleNodeContainerUI) {
        // SingleNodeContainer -> NodeContainerEditPart
        part = new NodeContainerEditPart();
    // we have to test for WorkflowInPort first because it's a
    // subclass of NodeInPort (same holds for WorkflowOutPort and
    // NodeOutPort)
    } else if (model instanceof WorkflowInPortUI && context instanceof WorkflowInPortBarEditPart) {
        // WorkflowInPort and context WorkflowRootEditPart ->
        // WorkflowInPortEditPart
        /*
             * if the context is a WorkflowRootEditPart it indicates that the
             * WorkflowInPort is a model child of the WorkflowRootEditPart, i.e.
             * we look at it as a workflow in port. If the context is a
             * NodeContainerEditPart the WorkflowInPort is a model child of a
             * NodeContainerEditPart and we look at it as a node in port.
             */
        WorkflowInPortUI inport = (WorkflowInPortUI) model;
        part = new WorkflowInPortEditPart(inport.getPortType(), inport.getPortIndex());
    } else if (model instanceof WorkflowOutPortUI && context instanceof WorkflowOutPortBarEditPart) {
        // WorkflowOutPort and context WorkflowRootEditPart ->
        // WorkflowOutPortEditPart
        /*
             * if the context is a WorkflowRootEditPart it indicates that the
             * WorkflowOutPort is a model child of the WorkflowRootEditPart,
             * i.e. we look at it as a workflow out port. If the context is a
             * NodeContainerEditPart the WorkflowOutPort is a model child of a
             * NodeContainerEditPart and we look at it as a node out port.
             */
        // TODO: return SubWorkFlowOutPortEditPart
        WorkflowOutPortUI outport = (WorkflowOutPortUI) model;
        part = new WorkflowOutPortEditPart(outport.getPortType(), outport.getPortIndex());
    } else if (model instanceof WorkflowOutPortUI) {
        // TODO: return SubWorkFlowOutPortEditPart
        WorkflowOutPortUI outport = (WorkflowOutPortUI) model;
        part = new MetaNodeOutPortEditPart(outport.getPortType(), outport.getPortIndex());
    } else if (model instanceof NodeInPortUI) {
        // NodeInPort -> NodeInPortEditPart
        NodePortUI port = (NodeInPortUI) model;
        part = new NodeInPortEditPart(port.getPortType(), port.getPortIndex());
    } else if (model instanceof NodeOutPortUI) {
        // NodeOutPort -> NodeOutPortEditPart
        NodePortUI port = (NodeOutPortUI) model;
        part = new NodeOutPortEditPart(port.getPortType(), port.getPortIndex());
    } else if (model instanceof ConnectionContainerUI) {
        // ConnectionContainer -> ConnectionContainerEditPart
        part = new ConnectionContainerEditPart();
    } else {
        throw new IllegalArgumentException("unknown model obj: " + model);
    }
    // associate the model with the part (= the controller)
    part.setModel(model);
    return part;
}

Example 13 with ConnectionContainerEditPart

use of org.knime.workbench.editor2.editparts.ConnectionContainerEditPart 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;
}

Example 14 with ConnectionContainerEditPart

use of org.knime.workbench.editor2.editparts.ConnectionContainerEditPart in project knime-core by knime.

the class PortGraphicalRoleEditPolicy method getReconnectTargetCommand.

/**
 * {@inheritDoc}
 */
@Override
protected Command getReconnectTargetCommand(final ReconnectRequest req) {
    // only connect to inports
    if (!(getHost() instanceof NodeInPortEditPart || getHost() instanceof WorkflowOutPortEditPart)) {
        return null;
    }
    // get new target in port
    AbstractPortEditPart target = (AbstractPortEditPart) req.getTarget();
    ReconnectConnectionCommand reconnectCmd = new ReconnectConnectionCommand((ConnectionContainerEditPart) req.getConnectionEditPart(), (AbstractPortEditPart) req.getConnectionEditPart().getSource(), target);
    return reconnectCmd;
}

Example 15 with ConnectionContainerEditPart

use of org.knime.workbench.editor2.editparts.ConnectionContainerEditPart in project knime-core by knime.

the class ConnectionBendpointEditPolicy method getCreateBendpointCommand.

/**
 * {@inheritDoc}
 */
protected Command getCreateBendpointCommand(final BendpointRequest req) {
    int index = req.getIndex();
    Point loc = req.getLocation();
    ConnectionContainerEditPart editPart = (ConnectionContainerEditPart) getHost();
    ZoomManager zoomManager = (ZoomManager) getHost().getRoot().getViewer().getProperty(ZoomManager.class.toString());
    return new NewBendpointCreateCommand(editPart, getWorkflowManager(), index, loc, zoomManager);
}