Package de.xima.fc.interfaces.workflow.bpmn

Interface IWorkflowBpmnLayoutSubProcessBuilder

    • Method Detail

      • addFlowPadding

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder addFlowPadding​(double spacingFactor)
        Adds padding to the given sub process on all four sides as if by calling enlargeInnerLengthBy for each side.

        Uses the flow direction spacing for the two sides in flow direction; and the cross flow direction spacing for the two sides in cross flow direction.

        Parameters:
        spacingFactor - The factor by which to multiply the flow and cross flow direction spacing. For example, if this factor is 2, the flow direction is EAST, the flow direction spacing is 10, and the cross flow direction spacing is 20; adds a spacing of 2*10 = 20 to the left and right side; and a spacing of 2*20 = 40 to the top and bottom side of the sub process.
        Returns:
        This builder for chaining method calls.

      • addFlowPadding

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder addFlowPadding​(double flowDirectionFactor,
                                                    double crossFlowDirectionFactor)
        Adds padding to the given sub process on all four sides as if by calling enlargeInnerLengthBy for each side.

        Uses the flow direction spacing for the two sides in flow direction; and the cross flow direction spacing for the two sides in cross flow direction.

        Parameters:
        flowDirectionFactor - The factor by which to multiply the flow direction spacing. For example, if this factor is 2, the flow direction is EAST and the flow direction spacing is 10, adds a spacing of 2*10 = 20 to the left side; and 2*10 = 20 to the right side of the sub process.
        crossFlowDirectionFactor - The factor by which to multiply the cross flow direction spacing. For example, if this factor is 2, the cross flow direction is EAST and the cross flow direction spacing is 10, adds a spacing of 2*10 = 20 to the top side; and 2*10 = 20 to the bottom side of the sub process.
        Returns:
        This builder for chaining method calls.

      • addFlowPadding

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder addFlowPadding​(double flowDirectionFactor,
                                                    double crossFlowDirectionFactor,
                                                    double reverseFlowDirectionFactor,
                                                    double reverseCrossFlowDirectionFactor)
        Adds padding to the given sub process on all four sides as if by calling enlargeInnerLengthBy for each side.

        Uses the flow direction spacing for the two sides in flow direction; and the cross flow direction spacing for the two sides in cross flow direction.

        Parameters:
        flowDirectionFactor - The factor by which to multiply the flow direction spacing for the side pointed to by the flow direction. For example, if this factor is 2, the flow direction is EAST and the flow direction spacing is 10, adds a spacing of 2*10 = 20 to the right side of the sub process.
        crossFlowDirectionFactor - The factor by which to multiply the cross flow direction spacing for the side pointed to by the cross flow direction. For example, if this factor is 2, the cross flow direction is EAST and the cross flow direction spacing is 10, adds a spacing of 2*10 = 20 to the top side of the sub process.
        reverseFlowDirectionFactor - The factor by which to multiply the flow direction spacing for the side pointed to by the reverse flow direction. For example, if this factor is 2, the flow direction is EAST and the flow direction spacing is 10, adds a spacing of 2*10 = 20 to the left side of the sub process.
        reverseCrossFlowDirectionFactor - The factor by which to multiply the cross flow direction spacing for the side pointed to by the reverse cross flow direction. For example, if this factor is 2, the cross flow direction is EAST and the cross flow direction spacing is 10, adds a spacing of 2*10 = 20 to the bottom side of the sub process.
        Returns:
        This builder for chaining method calls.

      • addFlowPaddingHalfForBoundaryEvents

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder addFlowPaddingHalfForBoundaryEvents​(double spacingFactor)
        Adds padding to the given sub process on all four sides as if by calling enlargeInnerLengthBy for each side.

        Uses the flow direction spacing for the two sides in flow direction; and the cross flow direction spacing for the two sides in cross flow direction.

        If there are boundary events on a side, halves the padding on that side.

        Parameters:
        spacingFactor - The factor by which to multiply the flow and cross flow direction spacing. For example, if this factor is 2, the flow direction is EAST, the flow direction spacing is 10, and the cross flow direction spacing is 20; adds a spacing of 2*10 = 20 to the left and right side; and a spacing of 2*20 = 40 to the top and bottom side of the sub process.
        Returns:
        This builder for chaining method calls.

      • addFlowPaddingHalfForBoundaryEvents

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder addFlowPaddingHalfForBoundaryEvents​(double flowDirectionFactor,
                                                                         double crossFlowDirectionFactor)
        Adds padding to the given sub process on all four sides as if by calling enlargeInnerLengthBy for each side.

        Uses the flow direction spacing for the two sides in flow direction; and the cross flow direction spacing for the two sides in cross flow direction.

        If there are boundary events on a side, halves the padding on that side.

        Parameters:
        flowDirectionFactor - The factor by which to multiply the flow direction spacing. For example, if this factor is 2, the flow direction is EAST and the flow direction spacing is 10, adds a spacing of 2*10 = 20 to the left side; and 2*10 = 20 to the right side of the sub process.
        crossFlowDirectionFactor - The factor by which to multiply the cross flow direction spacing. For example, if this factor is 2, the cross flow direction is EAST and the cross flow direction spacing is 10, adds a spacing of 2*10 = 20 to the top side; and 2*10 = 20 to the bottom side of the sub process.
        Returns:
        This builder for chaining method calls.

      • addFlowPaddingHalfForBoundaryEvents

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder addFlowPaddingHalfForBoundaryEvents​(double flowDirectionFactor,
                                                                         double crossFlowDirectionFactor,
                                                                         double reverseFlowDirectionFactor,
                                                                         double reverseCrossFlowDirectionFactor)
        Adds padding to the given sub process on all four sides as if by calling enlargeInnerLengthBy for each side.

        Uses the flow direction spacing for the two sides in flow direction; and the cross flow direction spacing for the two sides in cross flow direction.

        If there are boundary events on a side, halves the padding on that side.

        Parameters:
        flowDirectionFactor - The factor by which to multiply the flow direction spacing for the side pointed to by the flow direction. For example, if this factor is 2, the flow direction is EAST and the flow direction spacing is 10, adds a spacing of 2*10 = 20 to the right side of the sub process.
        crossFlowDirectionFactor - The factor by which to multiply the cross flow direction spacing for the side pointed to by the cross flow direction. For example, if this factor is 2, the cross flow direction is EAST and the cross flow direction spacing is 10, adds a spacing of 2*10 = 20 to the top side of the sub process.
        reverseFlowDirectionFactor - The factor by which to multiply the flow direction spacing for the side pointed to by the reverse flow direction. For example, if this factor is 2, the flow direction is EAST and the flow direction spacing is 10, adds a spacing of 2*10 = 20 to the left side of the sub process.
        reverseCrossFlowDirectionFactor - The factor by which to multiply the cross flow direction spacing for the side pointed to by the reverse cross flow direction. For example, if this factor is 2, the cross flow direction is EAST and the cross flow direction spacing is 10, adds a spacing of 2*10 = 20 to the bottom side of the sub process.
        Returns:
        This builder for chaining method calls.

      • addMargin

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder addMargin​(ICardinalDirection2DMapDouble margin)
        Sets the (minimum) margin of the sub process. The margin is the additional spacing outside the border of the sub process.
        Parameters:
        margin - The margin to apply in each of the four directions.
        Returns:
        This builder for chaining method calls.

      • addMargin

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder addMargin​(double margin)
        Adds the given amount of margin in all directions to the body.
        Parameters:
        margin - The amount of margin to add.
        Returns:
        This builder for chaining method calls.

      • addMargin

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder addMargin​(ECardinalDirection2D direction,
                                               double margin)
        Adds the given amount of margin in the given directions to the body.
        Parameters:
        direction - The direction where to add the margin.
        margin - The amount of margin to add.
        Returns:
        This builder for chaining method calls.

      • addPadding

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder addPadding​(double padding)
        Adds the given amount of padding in all directions to the body.
        Parameters:
        padding - The amount of padding to add.
        Returns:
        This builder for chaining method calls.

      • addPadding

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder addPadding​(ECardinalDirection2D direction,
                                                double padding)
        Adds the given amount of padding in the given directions to the body.
        Parameters:
        direction - The direction where to add the padding.
        padding - The amount of padding to add.
        Returns:
        This builder for chaining method calls.

      • alignBodyCrossFlow

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder alignBodyCrossFlow​(double alignment)
        Aligns the body in cross flow direction. Must be a value between 0 and 1. 0 is the start of the sub process, 1 is the end of the sub process.
        Parameters:
        alignment - The alignment of the body in cross flow direction.
        Returns:
        This builder for chaining method calls.

      • alignBodyFlow

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder alignBodyFlow​(double alignment)
        Aligns the body in flow direction. Must be a value between 0 and 1. 0 is the start of the sub process, 1 is the end of the sub process.
        Parameters:
        alignment - The alignment of the body in flow direction.
        Returns:
        This builder for chaining method calls.

      • alignBodyX

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder alignBodyX​(double alignX)
        Aligns the body in the x direction. Must be a value between 0 and 1. 0 is the left side of the sub process, 1 is the right side of the sub process.
        Parameters:
        alignX - The alignment of the body in x direction.
        Returns:
        This builder for chaining method calls.

      • alignBodyY

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder alignBodyY​(double alignY)
        Aligns the body in the y direction. Must be a value between 0 and 1. 0 is the top side of the sub process, 1 is the bottom side of the sub process.
        Parameters:
        alignY - The alignment of the body in y direction.
        Returns:
        This builder for chaining method calls.

      • appendBoundaryEvent

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder appendBoundaryEvent​(ECardinalDirection2D side,
                                                         double position,
                                                         de.xima.bpmn_model.api.element.bpmn.events.BoundaryEvent event,
                                                         IWorkflowBpmnAlignmentItem<?,​?> item)
        Appends a boundary event to the sub process at the given position on the given side. The position can be any value. If smaller than 0, adds space to the left or top. If greater than the length of the side, adds space to the right or bottom. If other events would overlap the newly inserted boundary event, they are shifted away.
        Parameters:
        side - The side where to append the boundary event.
        position - The position of the boundary on the given side.
        event - The boundary event to append.
        item - The alignment of the boundary event to append.

      • appendBoundaryEventAtEdge

        @CanIgnoreReturnValue
IAnnotatedNamedBpmnElementLayout<de.xima.bpmn_model.api.element.bpmn.events.BoundaryEvent> appendBoundaryEventAtEdge​(ECardinalDirection2D side,
                                                                                                                     EAxisPolarity direction,
                                                                                                                     de.xima.bpmn_model.api.element.bpmn.events.EventDefinition<?> eventDefinition,
                                                                                                                     String name)
        Appends a boundary event at one of the four sides of the sub process, either at the beginning or at the end of that side, depending on the given direction. If other events would overlap the newly inserted boundary event, they are shifted away in the given direction.
        Parameters:
        side - The side where to append the boundary event.
        direction - The edge direction where to append the boundary event. POSITIVE is the start of the edge, NEGATIVE is the end of the edge (with respect to a coordinate system where the x-axis points to the right and the y-axis points down).
        eventDefinition - The event definition to use for the boundary event.
        name - The name of the boundary event.
        Returns:
        The newly created layout with the boundary event.

      • appendBoundaryEventAtEdge

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder appendBoundaryEventAtEdge​(ECardinalDirection2D side,
                                                               EAxisPolarity direction,
                                                               de.xima.bpmn_model.api.element.bpmn.events.BoundaryEvent event,
                                                               IWorkflowBpmnAlignmentItem<?,​?> item)
        Appends a boundary event at one of the four sides of the sub process, either at the beginning or at the end of that side, depending on the given direction. If other events would overlap the newly inserted boundary event, they are shifted away in the given direction.
        Parameters:
        side - The side where to append the boundary event.
        direction - The edge direction where to append the boundary event. POSITIVE is the start of the edge, NEGATIVE is the end of the edge (with respect to a coordinate system where the x-axis points to the right and the y-axis points down).
        event - The boundary event to append.
        item - The alignment item containing the boundary event, either as it value or as the value of some child alignment item.
        Returns:
        This builder for chaining method calls.

      • appendBoundaryEventAtEdge

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder appendBoundaryEventAtEdge​(ECardinalDirection2D side,
                                                               EAxisPolarity direction,
                                                               IBpmnElementLayout<de.xima.bpmn_model.api.element.bpmn.events.BoundaryEvent> event)
        Appends a boundary event at one of the four sides of the sub process, either at the beginning or at the end of that side, depending on the given direction. If other events would overlap the newly inserted boundary event, they are shifted away in the given direction.
        Parameters:
        side - The side where to append the boundary event.
        direction - The edge direction where to append the boundary event. POSITIVE is the start of the edge, NEGATIVE is the end of the edge (with respect to a coordinate system where the x-axis points to the right and the y-axis points down).
        event - The laid out boundary event to append.
        Returns:
        This builder for chaining method calls.

      • appendBoundaryEventNextToEvent

        @CanIgnoreReturnValue
IAnnotatedNamedBpmnElementLayout<de.xima.bpmn_model.api.element.bpmn.events.BoundaryEvent> appendBoundaryEventNextToEvent​(ECardinalDirection2D side,
                                                                                                                          EAxisPolarity direction,
                                                                                                                          int boundaryEventIndex,
                                                                                                                          de.xima.bpmn_model.api.element.bpmn.events.EventDefinition<?> eventDefinition,
                                                                                                                          String name)
        Appends a boundary event next to an existing boundary event on one of the four sides of the sub process; either before or after the boundary event, depending on the given direction. If the specified boundary event does not exist (or no boundary events exists on the given side), this method behaves identical to appendBoundaryEventAtEdge(side, direction, eventDefinition, name). If other events would overlap the newly inserted boundary event, they are shifted away in the given direction.
        Parameters:
        side - The side where to append the boundary event.
        direction - Whether to append the boundary event before or after the existing boundary event. POSITIVE appends the boundary event after the existing boundary event, NEGATIVE appends it before the existing boundary event (with respect to a coordinate system where the x-axis points to the right and the y-axis points down).
        boundaryEventIndex - The index of the boundary event to append next to. 0 is the first boundary event, 1 is the second, etc. You can specify negative values to index events from the ends, e.g. -1 for the last event, -2 for the second to last, etc.
        eventDefinition - The event definition to use for the boundary event.
        name - The name of the boundary event.
        Returns:
        The newly created layout with the boundary event.

      • appendBoundaryEventNextToEvent

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder appendBoundaryEventNextToEvent​(ECardinalDirection2D side,
                                                                    EAxisPolarity direction,
                                                                    int boundaryEventIndex,
                                                                    de.xima.bpmn_model.api.element.bpmn.events.BoundaryEvent event,
                                                                    IWorkflowBpmnAlignmentItem<?,​?> item)
        Appends a boundary event next to an existing boundary event on one of the four sides of the sub process; either before or after the boundary event, depending on the given direction. If the specified boundary event does not exist (or no boundary events exists on the given side), this method behaves identical to appendBoundaryEventAtEdge(side, direction, event, item). If other events would overlap the newly inserted boundary event, they are shifted away in the given direction.
        Parameters:
        side - The side where to append the boundary event.
        direction - Whether to append the boundary event before or after the existing boundary event. POSITIVE appends the boundary event after the existing boundary event, NEGATIVE appends it before the existing boundary event (with respect to a coordinate system where the x-axis points to the right and the y-axis points down).
        boundaryEventIndex - The index of the boundary event to append next to. 0 is the first boundary event, 1 is the second, etc. You can specify negative values to index events from the ends, e.g. -1 for the last event, -2 for the second to last, etc.
        item - The alignment item containing the boundary event, either as it value or as the value of some childAlignmentItems.
        event - The boundary event to append.
        Returns:
        This builder for chaining method calls.

      • appendBoundaryEventNextToEvent

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder appendBoundaryEventNextToEvent​(ECardinalDirection2D side,
                                                                    EAxisPolarity direction,
                                                                    int boundaryEventIndex,
                                                                    IBpmnElementLayout<de.xima.bpmn_model.api.element.bpmn.events.BoundaryEvent> event)
        Appends a boundary event next to an existing boundary event on one of the four sides of the sub process; either before or after the boundary event, depending on the given direction. If the specified boundary event does not exist (or no boundary events exists on the given side), this method behaves identical to appendBoundaryEventAtEdge(side, direction, event). If other events would overlap the newly inserted boundary event, they are shifted away in the given direction.
        Parameters:
        side - The side where to append the boundary event.
        direction - Whether to append the boundary event before or after the existing boundary event. POSITIVE appends the boundary event after the existing boundary event, NEGATIVE appends it before the existing boundary event (with respect to a coordinate system where the x-axis points to the right and the y-axis points down).
        boundaryEventIndex - The index of the boundary event to append next to. 0 is the first boundary event, 1 is the second, etc. You can specify negative values to index events from the ends, e.g. -1 for the last event, -2 for the second to last, etc.
        event - The laid out boundary event to append.
        Returns:
        This builder for chaining method calls.

      • appendBoundaryEventNextToPort

        @CanIgnoreReturnValue
IAnnotatedNamedBpmnElementLayout<de.xima.bpmn_model.api.element.bpmn.events.BoundaryEvent> appendBoundaryEventNextToPort​(EAxisPolarity portSide,
                                                                                                                         EAxisPolarity direction,
                                                                                                                         de.xima.bpmn_model.api.element.bpmn.events.EventDefinition<?> eventDefinition,
                                                                                                                         String name)
        Appends a boundary event next to the in or out port of the sub process; either before or after the port, depending on the given direction. If other events would overlap the newly inserted boundary event, they are shifted away in the given direction.
        Parameters:
        portSide - The side where to append the boundary event.
        direction - Whether to append the boundary event before or after the port. POSITIVE appends the boundary event after the port, NEGATIVE appends it before the port (with respect to a coordinate system where the x-axis points to the right and the y-axis points down).
        eventDefinition - The event definition to use for the boundary event.
        name - The name of the boundary event.
        Returns:
        The newly created layout with the boundary event.

      • appendBoundaryEventNextToPort

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder appendBoundaryEventNextToPort​(EAxisPolarity portSide,
                                                                   EAxisPolarity direction,
                                                                   de.xima.bpmn_model.api.element.bpmn.events.BoundaryEvent event,
                                                                   IWorkflowBpmnAlignmentItem<?,​?> item)
        Appends a boundary event next to the in or out port of the sub process; either before or after the port, depending on the given direction. If other events would overlap the newly inserted boundary event, they are shifted away in the given direction.
        Parameters:
        portSide - The side where to append the boundary event.
        direction - Whether to append the boundary event before or after the port. POSITIVE appends the boundary event after the port, NEGATIVE appends it before the port (with respect to a coordinate system where the x-axis points to the right and the y-axis points down).
        event - The boundary event to append.
        item - The alignment item containing the boundary event, either as it value or as the value of some child alignment item.
        Returns:
        This builder for chaining method calls.

      • appendBoundaryEventNextToPort

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder appendBoundaryEventNextToPort​(EAxisPolarity portSide,
                                                                   EAxisPolarity direction,
                                                                   IBpmnElementLayout<de.xima.bpmn_model.api.element.bpmn.events.BoundaryEvent> event)
        Appends a boundary event next to the in or out port of the sub process; either before or after the port, depending on the given direction. If other events would overlap the newly inserted boundary event, they are shifted away in the given direction.
        Parameters:
        portSide - The side where to append the boundary event.
        direction - Whether to append the boundary event before or after the port. POSITIVE appends the boundary event after the port, NEGATIVE appends it before the port (with respect to a coordinate system where the x-axis points to the right and the y-axis points down).
        event - The laid out boundary event to append.
        Returns:
        This builder for chaining method calls.

      • bodyWithStartAndEndEvent

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder bodyWithStartAndEndEvent​(IWorkflowBpmnAlignmentItem<?,​?> body,
                                                              String startEventName,
                                                              String endEventName)
        Adds a start and end event to the given body and sets the resulting alignment items as the body. The start event is added only when the given loop body has an in port; the end event is added only when the given body has an out port.
        Parameters:
        body - The body content.
        startEventName - The name of the start event.
        endEventName - The name of the end event.
        Returns:
        This builder for chaining method calls.

      • boundaryEvent

        de.xima.bpmn_model.api.element.bpmn.events.BoundaryEvent boundaryEvent​(ECardinalDirection2D side,
                                                                       int index)
        Gets the nth BoundaryEvent BPMN element at the given side.
        Parameters:
        side - The side to get the boundary event from.
        index - The index of the boundary event. 0 is the first boundary event, 1 is the second, etc. You can specify negative values to index events from the ends, e.g. -1 is the last event, -2 is the second to last, etc.
        Returns:
        The boundary event at the given side and index.
        Throws:
        IndexOutOfBoundsException - If the index is out of bounds.

      • boundaryEventCount

        int boundaryEventCount​(ECardinalDirection2D side)
        Gets the number of boundary events on the given side.
        Parameters:
        side - The side to get the number of boundary events on.
        Returns:
        The number of boundary events on the given side.

      • boundaryEventPosition

        double boundaryEventPosition​(ECardinalDirection2D side,
                             int index)
        Gets the position of the nth boundary event on the given side
        Parameters:
        side - The side to get the position of the boundary event on.
        index - The index of the boundary event. 0 is the first boundary event, 1 is the second, etc. You can specify negative values to index events from the ends, e.g. -1 is the last event, -2 is the second to last, etc.
        Returns:
        The position of the boundary event on the given side.
        Throws:
        IndexOutOfBoundsException - If the index is out of bounds.

      • build

        <S extends de.xima.bpmn_model.api.element.bpmn.activities.SubProcess<?>> ISubProcessBpmnElementLayout<S> build​(S subProcess)
        Creates the layout for the given sub process, using the current layout settings.
        Type Parameters:
        S - The type of the sub process.
        Parameters:
        subProcess - The sub process to create the layout for.
        Returns:
        The layout for the sub process.

      • changeInPort

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder changeInPort​(double inPort)
        Override the position of the in port. By default, the in port is set to align with the in port of the body.
        Parameters:
        inPort - The position of the in port.
        Returns:
        This builder for chaining method calls.

      • changeOutPort

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder changeOutPort​(double outPort)
        Override the position of the out port. By default, the out port is set to align with the out port of the body.
        Parameters:
        outPort - The position of the out port.
        Returns:
        This builder for chaining method calls.

      • enlargeInnerHeightBottom

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeInnerHeightBottom​(double height)
        Increases the inner height of the sub process to the given value by adding new space at the bottom. Does nothing when the height is already greater than the given value.
        Parameters:
        height - The new inner height of the sub process.
        Returns:
        This builder for chaining method calls.

      • enlargeInnerHeightBottomBy

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeInnerHeightBottomBy​(double amount)
        Increases the inner height of the sub process by the given amount, adding new space at the bottom.
        Parameters:
        amount - The amount to increase the inner height by.

      • enlargeInnerHeightTop

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeInnerHeightTop​(double height)
        Increases the inner height of the sub process to the given value by adding new space at the top. Does nothing when the height is already greater than the given value.
        Parameters:
        height - The new inner height of the sub process.

      • enlargeInnerHeightTopBy

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeInnerHeightTopBy​(double amount)
        Increases the inner height of the sub process by the given amount, adding new space at the top.
        Parameters:
        amount - The amount to increase the inner height by.

      • enlargeInnerLength

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeInnerLength​(ECartesianAxis2D axis,
                                                        EAxisPolarity direction,
                                                        double length)
        Increases the inner length of the sub process to the given value by adding new space at the given side. Does nothing when the length is already greater than the given value.
        Parameters:
        axis - The axis of the ECardinalDirection2D pointing to the side to enlarge.
        direction - The direction of the ECardinalDirection2D pointing to the side to enlarge.
        length - The new inner length of the sub process.
        Returns:
        This builder for chaining method calls.

      • enlargeInnerLength

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeInnerLength​(ECardinalDirection2D side,
                                                        double length)
        Increases the inner length of the sub process to the given value by adding new space at the given side. Does nothing when the length is already greater than the given value.
        Parameters:
        side - The direction pointing to the side to enlarge.
        length - The new inner length of the sub process.
        Returns:
        This builder for chaining method calls.

      • enlargeInnerLengthBy

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeInnerLengthBy​(ECardinalDirection2D side,
                                                          double amount)
        Increases the inner length of the sub process by the given amount at the given side, adding new space at that side.
        Parameters:
        side - The direction pointing to the side to enlarge.
        amount - The amount to increase the inner length by.

      • enlargeInnerWidthLeft

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeInnerWidthLeft​(double width)
        Increases the inner width of the sub process to the given value by adding new space at the left. Does nothing when the width is already greater than the given value.
        Parameters:
        width - The new inner width of the sub process.

      • enlargeInnerWidthLeftBy

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeInnerWidthLeftBy​(double amount)
        Increases the inner width of the sub process by adding new space at the left.
        Parameters:
        amount - The amount to increase the inner width by.

      • enlargeInnerWidthRight

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeInnerWidthRight​(double width)
        Increases the inner width of the sub process to the given value by adding new space at the right. Does nothing when the width is already greater than the given value.
        Parameters:
        width - The new inner width of the sub process.

      • enlargeInnerWidthRightBy

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeInnerWidthRightBy​(double amount)
        Increases the inner width of the sub process by adding new space at the right.
        Parameters:
        amount - The amount to increase the inner width by.

      • enlargeOuterHeightBottom

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeOuterHeightBottom​(double height)
        Increases the outer height of the sub process to the given value by adding new space at the bottom. Does nothing when the height is already greater than the given value.
        Parameters:
        height - The new outer height of the sub process.
        Returns:
        This builder for chaining method calls.

      • enlargeOuterHeightBottomBy

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeOuterHeightBottomBy​(double amount)
        Increases the outer height of the sub process by the given amount, adding new space at the bottom.
        Parameters:
        amount - The amount to increase the outer height by.

      • enlargeOuterHeightTop

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeOuterHeightTop​(double height)
        Increases the outer height of the sub process to the given value by adding new space at the top. Does nothing when the height is already greater than the given value.
        Parameters:
        height - The new outer height of the sub process.

      • enlargeOuterHeightTopBy

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeOuterHeightTopBy​(double amount)
        Increases the outer height of the sub process by the given amount, adding new space at the top.
        Parameters:
        amount - The amount to increase the outer height by.

      • enlargeOuterLength

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeOuterLength​(ECartesianAxis2D axis,
                                                        EAxisPolarity direction,
                                                        double length)
        Increases the outer length of the sub process to the given value by adding new space at the given side. Does nothing when the length is already greater than the given value.
        Parameters:
        axis - The axis of the ECardinalDirection2D pointing to the side to enlarge.
        direction - The direction of the ECardinalDirection2D pointing to the side to enlarge.
        length - The new outer length of the sub process.
        Returns:
        This builder for chaining method calls.

      • enlargeOuterLength

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeOuterLength​(ECardinalDirection2D side,
                                                        double length)
        Increases the outer length of the sub process to the given value by adding new space at the given side. Does nothing when the length is already greater than the given value.
        Parameters:
        side - The direction pointing to the side to enlarge.
        length - The new outer length of the sub process.
        Returns:
        This builder for chaining method calls.

      • enlargeOuterLengthBy

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeOuterLengthBy​(ECardinalDirection2D side,
                                                          double amount)
        Increases the outer length of the sub process by the given amount at the given side, adding new space at that side.
        Parameters:
        side - The direction pointing to the side to enlarge.
        amount - The amount to increase the outer length by.

      • enlargeOuterWidthLeft

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeOuterWidthLeft​(double width)
        Increases the outer width of the sub process to the given value by adding new space at the left. Does nothing when the width is already greater than the given value.
        Parameters:
        width - The new outer width of the sub process.

      • enlargeOuterWidthLeftBy

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeOuterWidthLeftBy​(double amount)
        Increases the outer width of the sub process by adding new space at the left.
        Parameters:
        amount - The amount to increase the outer width by.

      • enlargeOuterWidthRight

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeOuterWidthRight​(double width)
        Increases the outer width of the sub process to the given value by adding new space at the right. Does nothing when the width is already greater than the given value.
        Parameters:
        width - The new outer width of the sub process.

      • enlargeOuterWidthRightBy

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder enlargeOuterWidthRightBy​(double amount)
        Increases the outer width of the sub process by adding new space at the right.
        Parameters:
        amount - The amount to increase the outer width by.

      • hasBoundaryEvents

        boolean hasBoundaryEvents​(ECardinalDirection2D side)
        Checks whether the sub process has any boundary events on the given side.
        Parameters:
        side - The side to check for boundary events.
        Returns:
        True if the sub process has any boundary events on the given side, false otherwise.

      • inPort

        @CanIgnoreReturnValue
Double inPort()
        Gets the current position of the in port.
        Returns:
        The current position of the in port.

      • innerBoundingBox

        Rectangular2DDouble innerBoundingBox()
        Gets the current inner width and inner height of the sub process.
        Returns:
        The current inner width and inner height of the sub process.

      • innerHeight

        double innerHeight()
        Gets the current inner height of the sub process. The inner height includes the padding, but not the margin. In other words, the inner height is the height of the rectangle that visualizes the sub process.
        Returns:
        The current inner height of the sub process.

      • innerWidth

        double innerWidth()
        Gets the current inner width of the sub process. The inner width includes the padding, but not the margin. In other words, the inner width is the width of the rectangle that visualizes the sub process.
        Returns:
        The current inner width of the sub process.

      • outPort

        @CanIgnoreReturnValue
Double outPort()
        Gets the current position of the out port.
        Returns:
        The current position of the out port.

      • outerBoundingBox

        Rectangular2DDouble outerBoundingBox()
        Gets the current outer width and outer height of the sub process.
        Returns:
        The current outer width and outer height of the sub process.

      • outerHeight

        double outerHeight()
        Gets the current outer height of the sub process. The outer height includes the padding and the margin. In other words, the outer height is the height of the final alignment item created by the build method (but note that the build method may increase the padding / margin if needed).
        Returns:
        The current outer height of the sub process.

      • outerWidth

        double outerWidth()
        Gets the current outer width of the sub process. The outer width includes the padding and the margin. In other words, the outer width is the width of the final alignment item created by the build method (but note that the build method may increase the padding / margin if needed).
        Returns:
        The current outer width of the sub process.

      • portDirection

        ECardinalDirection2D portDirection()
        Gets the current port direction, either the default direction or the direction set by portDirection(side).
        Returns:
        The current port direction.

      • spaceBoundaryEventsEvenly

        @CanIgnoreReturnValue
IWorkflowBpmnLayoutSubProcessBuilder spaceBoundaryEventsEvenly​(ECardinalDirection2D side)
        Repositions all boundary events on the given side that were added via appendBoundaryEvent. Spaces them evenly on the given side, using the current length of that side. Ignores the in and out ports, if any are present. This works similar to the CSS flexbox property justify-content: space-evenly.
        Parameters:
        side - The side to space the boundary events on.
        Returns:
        This builder for chaining method calls.