bpmn-js 16.3.2 → 16.4.0

package/lib/features/modeling/behavior/DeleteLaneBehavior.js

@@ -8,6 +8,10 @@ import {
   getChildLanes
 } from '../util/LaneUtil';
 
+import {
+  isHorizontal
+} from '../../../util/DiUtil';
+
 import {
   eachElement
 } from 'diagram-js/lib/util/Elements';
@@ -32,18 +36,29 @@ export default function DeleteLaneBehavior(eventBus, spaceTool) {
 
 
   function compensateLaneDelete(shape, oldParent) {
+    var isHorizontalLane = isHorizontal(shape);
 
     var siblings = getChildLanes(oldParent);
 
     var topAffected = [];
     var bottomAffected = [];
+    var leftAffected = [];
+    var rightAffected = [];
 
     eachElement(siblings, function(element) {
 
-      if (element.y > shape.y) {
-        bottomAffected.push(element);
+      if (isHorizontalLane) {
+        if (element.y > shape.y) {
+          bottomAffected.push(element);
+        } else {
+          topAffected.push(element);
+        }
       } else {
-        topAffected.push(element);
+        if (element.x > shape.x) {
+          rightAffected.push(element);
+        } else {
+          leftAffected.push(element);
+        }
       }
 
       return element.children;
@@ -55,14 +70,24 @@ export default function DeleteLaneBehavior(eventBus, spaceTool) {
 
     var offset;
 
-    if (bottomAffected.length && topAffected.length) {
-      offset = shape.height / 2;
+    if (isHorizontalLane) {
+      if (bottomAffected.length && topAffected.length) {
+        offset = shape.height / 2;
+      } else {
+        offset = shape.height;
+      }
     } else {
-      offset = shape.height;
+      if (rightAffected.length && leftAffected.length) {
+        offset = shape.width / 2;
+      } else {
+        offset = shape.width;
+      }
     }
 
     var topAdjustments,
-        bottomAdjustments;
+        bottomAdjustments,
+        leftAdjustments,
+        rightAdjustments;
 
     if (topAffected.length) {
       topAdjustments = spaceTool.calculateAdjustments(
@@ -83,6 +108,26 @@ export default function DeleteLaneBehavior(eventBus, spaceTool) {
         bottomAdjustments.resizingShapes,
         { x: 0, y: -offset }, 'n');
     }
+
+    if (leftAffected.length) {
+      leftAdjustments = spaceTool.calculateAdjustments(
+        leftAffected, 'x', offset, shape.x - 10);
+
+      spaceTool.makeSpace(
+        leftAdjustments.movingShapes,
+        leftAdjustments.resizingShapes,
+        { x: offset, y: 0 }, 'e');
+    }
+
+    if (rightAffected.length) {
+      rightAdjustments = spaceTool.calculateAdjustments(
+        rightAffected, 'x', -offset, shape.x + shape.width + 10);
+
+      spaceTool.makeSpace(
+        rightAdjustments.movingShapes,
+        rightAdjustments.resizingShapes,
+        { x: -offset, y: 0 }, 'w');
+    }
   }
 
 

package/lib/features/modeling/behavior/FixHoverBehavior.js

@@ -1,8 +1,6 @@
 import { getLanesRoot } from '../util/LaneUtil';
 
-import { is } from '../../../util/ModelUtil';
-
-import { isAny } from '../util/ModelingUtil';
+import { is, isAny } from '../../../util/ModelUtil';
 
 /**
  * @typedef {import('diagram-js/lib/core/ElementRegistry').default} ElementRegistry
@@ -48,7 +46,7 @@ export default function FixHoverBehavior(elementRegistry, eventBus, canvas) {
 
     // ensure bpmn:Group and label elements are dropped
     // always onto the root
-    if (hover !== rootElement && (shape.labelTarget || is(shape, 'bpmn:Group'))) {
+    if (hover !== rootElement && (shape.labelTarget || isAny(shape, [ 'bpmn:Group', 'bpmn:TextAnnotation' ]))) {
       event.hover = rootElement;
       event.hoverGfx = elementRegistry.getGraphics(event.hover);
     }

package/lib/features/modeling/behavior/ResizeBehavior.d.ts

@@ -20,11 +20,21 @@ export const GROUP_MIN_DIMENSIONS: Dimensions;
  */
 export const LANE_MIN_DIMENSIONS: Dimensions;
 
+/**
+ * @type {Dimensions}
+ */
+export const VERTICAL_LANE_MIN_DIMENSIONS: Dimensions;
+
 /**
  * @type {Dimensions}
  */
 export const PARTICIPANT_MIN_DIMENSIONS: Dimensions;
 
+/**
+ * @type {Dimensions}
+ */
+export const VERTICAL_PARTICIPANT_MIN_DIMENSIONS: Dimensions;
+
 /**
  * @type {Dimensions}
  */

package/lib/features/modeling/behavior/ResizeBehavior.js

@@ -1,211 +1,263 @@
-import { is } from '../../../util/ModelUtil';
-
-import { isExpanded } from '../../../util/DiUtil';
-
-import {
-  asTRBL
-} from 'diagram-js/lib/layout/LayoutUtil';
-
-import {
-  collectLanes,
-  getLanesRoot
-} from '../util/LaneUtil';
-
-var HIGH_PRIORITY = 1500;
-
-/**
- * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
- *
- * @typedef {import('../../../model/Types').Shape} Shape
- *
- * @typedef {import('diagram-js/lib/util/Types').Dimensions} Dimensions
- * @typedef {import('diagram-js/lib/util/Types').Direction} Direction
- * @typedef {import('diagram-js/lib/util/Types').RectTRBL} RectTRBL
- */
-
-/**
- * @type {Dimensions}
- */
-export var GROUP_MIN_DIMENSIONS = { width: 140, height: 120 };
-
-/**
- * @type {Dimensions}
- */
-export var LANE_MIN_DIMENSIONS = { width: 300, height: 60 };
-
-/**
- * @type {Dimensions}
- */
-export var PARTICIPANT_MIN_DIMENSIONS = { width: 300, height: 150 };
-
-/**
- * @type {Dimensions}
- */
-export var SUB_PROCESS_MIN_DIMENSIONS = { width: 140, height: 120 };
-
-/**
- * @type {Dimensions}
- */
-export var TEXT_ANNOTATION_MIN_DIMENSIONS = { width: 50, height: 30 };
-
-/**
- * Set minimum bounds/resize constraints on resize.
- *
- * @param {EventBus} eventBus
- */
-export default function ResizeBehavior(eventBus) {
-  eventBus.on('resize.start', HIGH_PRIORITY, function(event) {
-    var context = event.context,
-        shape = context.shape,
-        direction = context.direction,
-        balanced = context.balanced;
-
-    if (is(shape, 'bpmn:Lane') || is(shape, 'bpmn:Participant')) {
-      context.resizeConstraints = getParticipantResizeConstraints(shape, direction, balanced);
-    }
-
-    if (is(shape, 'bpmn:Participant')) {
-      context.minDimensions = PARTICIPANT_MIN_DIMENSIONS;
-    }
-
-    if (is(shape, 'bpmn:SubProcess') && isExpanded(shape)) {
-      context.minDimensions = SUB_PROCESS_MIN_DIMENSIONS;
-    }
-
-    if (is(shape, 'bpmn:TextAnnotation')) {
-      context.minDimensions = TEXT_ANNOTATION_MIN_DIMENSIONS;
-    }
-  });
-}
-
-ResizeBehavior.$inject = [ 'eventBus' ];
-
-
-var abs = Math.abs,
-    min = Math.min,
-    max = Math.max;
-
-
-function addToTrbl(trbl, attr, value, choice) {
-  var current = trbl[attr];
-
-  // make sure to set the value if it does not exist
-  // or apply the correct value by comparing against
-  // choice(value, currentValue)
-  trbl[attr] = current === undefined ? value : choice(value, current);
-}
-
-function addMin(trbl, attr, value) {
-  return addToTrbl(trbl, attr, value, min);
-}
-
-function addMax(trbl, attr, value) {
-  return addToTrbl(trbl, attr, value, max);
-}
-
-var LANE_RIGHT_PADDING = 20,
-    LANE_LEFT_PADDING = 50,
-    LANE_TOP_PADDING = 20,
-    LANE_BOTTOM_PADDING = 20;
-
-/**
- * @param {Shape} laneShape
- * @param {Direction} resizeDirection
- * @param {boolean} [balanced=false]
- *
- * @return { {
- *   min: RectTRBL;
- *   max: RectTRBL;
- * } }
- */
-export function getParticipantResizeConstraints(laneShape, resizeDirection, balanced) {
-  var lanesRoot = getLanesRoot(laneShape);
-
-  var isFirst = true,
-      isLast = true;
-
-  // max top/bottom size for lanes
-  var allLanes = collectLanes(lanesRoot, [ lanesRoot ]);
-
-  var laneTrbl = asTRBL(laneShape);
-
-  var maxTrbl = {},
-      minTrbl = {};
-
-  if (/e/.test(resizeDirection)) {
-    minTrbl.right = laneTrbl.left + LANE_MIN_DIMENSIONS.width;
-  } else
-  if (/w/.test(resizeDirection)) {
-    minTrbl.left = laneTrbl.right - LANE_MIN_DIMENSIONS.width;
-  }
-
-  allLanes.forEach(function(other) {
-
-    var otherTrbl = asTRBL(other);
-
-    if (/n/.test(resizeDirection)) {
-
-      if (otherTrbl.top < (laneTrbl.top - 10)) {
-        isFirst = false;
-      }
-
-      // max top size (based on next element)
-      if (balanced && abs(laneTrbl.top - otherTrbl.bottom) < 10) {
-        addMax(maxTrbl, 'top', otherTrbl.top + LANE_MIN_DIMENSIONS.height);
-      }
-
-      // min top size (based on self or nested element)
-      if (abs(laneTrbl.top - otherTrbl.top) < 5) {
-        addMin(minTrbl, 'top', otherTrbl.bottom - LANE_MIN_DIMENSIONS.height);
-      }
-    }
-
-    if (/s/.test(resizeDirection)) {
-
-      if (otherTrbl.bottom > (laneTrbl.bottom + 10)) {
-        isLast = false;
-      }
-
-      // max bottom size (based on previous element)
-      if (balanced && abs(laneTrbl.bottom - otherTrbl.top) < 10) {
-        addMin(maxTrbl, 'bottom', otherTrbl.bottom - LANE_MIN_DIMENSIONS.height);
-      }
-
-      // min bottom size (based on self or nested element)
-      if (abs(laneTrbl.bottom - otherTrbl.bottom) < 5) {
-        addMax(minTrbl, 'bottom', otherTrbl.top + LANE_MIN_DIMENSIONS.height);
-      }
-    }
-  });
-
-  // max top/bottom/left/right size based on flow nodes
-  var flowElements = lanesRoot.children.filter(function(s) {
-    return !s.hidden && !s.waypoints && (is(s, 'bpmn:FlowElement') || is(s, 'bpmn:Artifact'));
-  });
-
-  flowElements.forEach(function(flowElement) {
-
-    var flowElementTrbl = asTRBL(flowElement);
-
-    if (isFirst && /n/.test(resizeDirection)) {
-      addMin(minTrbl, 'top', flowElementTrbl.top - LANE_TOP_PADDING);
-    }
-
-    if (/e/.test(resizeDirection)) {
-      addMax(minTrbl, 'right', flowElementTrbl.right + LANE_RIGHT_PADDING);
-    }
-
-    if (isLast && /s/.test(resizeDirection)) {
-      addMax(minTrbl, 'bottom', flowElementTrbl.bottom + LANE_BOTTOM_PADDING);
-    }
-
-    if (/w/.test(resizeDirection)) {
-      addMin(minTrbl, 'left', flowElementTrbl.left - LANE_LEFT_PADDING);
-    }
-  });
-
-  return {
-    min: minTrbl,
-    max: maxTrbl
-  };
+import { is } from '../../../util/ModelUtil';
+
+import {
+  isExpanded,
+  isHorizontal
+} from '../../../util/DiUtil';
+
+import {
+  asTRBL
+} from 'diagram-js/lib/layout/LayoutUtil';
+
+import {
+  collectLanes,
+  getLanesRoot
+} from '../util/LaneUtil';
+
+var HIGH_PRIORITY = 1500;
+
+/**
+ * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+ *
+ * @typedef {import('../../../model/Types').Shape} Shape
+ *
+ * @typedef {import('diagram-js/lib/util/Types').Dimensions} Dimensions
+ * @typedef {import('diagram-js/lib/util/Types').Direction} Direction
+ * @typedef {import('diagram-js/lib/util/Types').RectTRBL} RectTRBL
+ */
+
+/**
+ * @type {Dimensions}
+ */
+export var GROUP_MIN_DIMENSIONS = { width: 140, height: 120 };
+
+/**
+ * @type {Dimensions}
+ */
+export var LANE_MIN_DIMENSIONS = { width: 300, height: 60 };
+
+/**
+ * @type {Dimensions}
+ */
+export var VERTICAL_LANE_MIN_DIMENSIONS = { width: 60, height: 300 };
+
+/**
+ * @type {Dimensions}
+ */
+export var PARTICIPANT_MIN_DIMENSIONS = { width: 300, height: 150 };
+
+/**
+ * @type {Dimensions}
+ */
+export var VERTICAL_PARTICIPANT_MIN_DIMENSIONS = { width: 150, height: 300 };
+
+/**
+ * @type {Dimensions}
+ */
+export var SUB_PROCESS_MIN_DIMENSIONS = { width: 140, height: 120 };
+
+/**
+ * @type {Dimensions}
+ */
+export var TEXT_ANNOTATION_MIN_DIMENSIONS = { width: 50, height: 30 };
+
+/**
+ * Set minimum bounds/resize constraints on resize.
+ *
+ * @param {EventBus} eventBus
+ */
+export default function ResizeBehavior(eventBus) {
+  eventBus.on('resize.start', HIGH_PRIORITY, function(event) {
+    var context = event.context,
+        shape = context.shape,
+        direction = context.direction,
+        balanced = context.balanced;
+
+    if (is(shape, 'bpmn:Lane') || is(shape, 'bpmn:Participant')) {
+      context.resizeConstraints = getParticipantResizeConstraints(shape, direction, balanced);
+    }
+
+    if (is(shape, 'bpmn:SubProcess') && isExpanded(shape)) {
+      context.minDimensions = SUB_PROCESS_MIN_DIMENSIONS;
+    }
+
+    if (is(shape, 'bpmn:TextAnnotation')) {
+      context.minDimensions = TEXT_ANNOTATION_MIN_DIMENSIONS;
+    }
+  });
+}
+
+ResizeBehavior.$inject = [ 'eventBus' ];
+
+
+var abs = Math.abs,
+    min = Math.min,
+    max = Math.max;
+
+
+function addToTrbl(trbl, attr, value, choice) {
+  var current = trbl[attr];
+
+  // make sure to set the value if it does not exist
+  // or apply the correct value by comparing against
+  // choice(value, currentValue)
+  trbl[attr] = current === undefined ? value : choice(value, current);
+}
+
+function addMin(trbl, attr, value) {
+  return addToTrbl(trbl, attr, value, min);
+}
+
+function addMax(trbl, attr, value) {
+  return addToTrbl(trbl, attr, value, max);
+}
+
+var LANE_PADDING = { top: 20, left: 50, right: 20, bottom: 20 },
+    VERTICAL_LANE_PADDING = { top: 50, left: 20, right: 20, bottom: 20 };
+
+/**
+ * @param {Shape} laneShape
+ * @param {Direction} resizeDirection
+ * @param {boolean} [balanced=false]
+ *
+ * @return { {
+ *   min: RectTRBL;
+ *   max: RectTRBL;
+ * } }
+ */
+export function getParticipantResizeConstraints(laneShape, resizeDirection, balanced) {
+  var lanesRoot = getLanesRoot(laneShape);
+
+  var isFirst = true,
+      isLast = true;
+
+  var allLanes = collectLanes(lanesRoot, [ lanesRoot ]);
+
+  var laneTrbl = asTRBL(laneShape);
+
+  var maxTrbl = {},
+      minTrbl = {};
+
+  var isHorizontalLane = isHorizontal(laneShape);
+
+  var minDimensions = isHorizontalLane ? LANE_MIN_DIMENSIONS : VERTICAL_LANE_MIN_DIMENSIONS;
+
+  if (/n/.test(resizeDirection)) {
+    minTrbl.top = laneTrbl.bottom - minDimensions.height;
+  } else
+  if (/e/.test(resizeDirection)) {
+    minTrbl.right = laneTrbl.left + minDimensions.width;
+  } else
+  if (/s/.test(resizeDirection)) {
+    minTrbl.bottom = laneTrbl.top + minDimensions.height;
+  } else
+  if (/w/.test(resizeDirection)) {
+    minTrbl.left = laneTrbl.right - minDimensions.width;
+  }
+
+  // min/max size based on related lanes
+  allLanes.forEach(function(other) {
+
+    var otherTrbl = asTRBL(other);
+
+    if (/n/.test(resizeDirection)) {
+      if (isHorizontalLane && otherTrbl.top < (laneTrbl.top - 10)) {
+        isFirst = false;
+      }
+
+      // max top size (based on next element)
+      if (balanced && abs(laneTrbl.top - otherTrbl.bottom) < 10) {
+        addMax(maxTrbl, 'top', otherTrbl.top + minDimensions.height);
+      }
+
+      // min top size (based on self or nested element)
+      if (abs(laneTrbl.top - otherTrbl.top) < 5) {
+        addMin(minTrbl, 'top', otherTrbl.bottom - minDimensions.height);
+      }
+    }
+
+    if (/e/.test(resizeDirection)) {
+
+      if (!isHorizontalLane && otherTrbl.right > (laneTrbl.right + 10)) {
+        isLast = false;
+      }
+
+      // max right size (based on previous element)
+      if (balanced && abs(laneTrbl.right - otherTrbl.left) < 10) {
+        addMin(maxTrbl, 'right', otherTrbl.right - minDimensions.width);
+      }
+
+      // min right size (based on self or nested element)
+      if (abs(laneTrbl.right - otherTrbl.right) < 5) {
+        addMax(minTrbl, 'right', otherTrbl.left + minDimensions.width);
+      }
+    }
+
+    if (/s/.test(resizeDirection)) {
+
+      if (isHorizontalLane && otherTrbl.bottom > (laneTrbl.bottom + 10)) {
+        isLast = false;
+      }
+
+      // max bottom size (based on previous element)
+      if (balanced && abs(laneTrbl.bottom - otherTrbl.top) < 10) {
+        addMin(maxTrbl, 'bottom', otherTrbl.bottom - minDimensions.height);
+      }
+
+      // min bottom size (based on self or nested element)
+      if (abs(laneTrbl.bottom - otherTrbl.bottom) < 5) {
+        addMax(minTrbl, 'bottom', otherTrbl.top + minDimensions.height);
+      }
+    }
+
+    if (/w/.test(resizeDirection)) {
+
+      if (!isHorizontalLane && otherTrbl.left < (laneTrbl.left - 10)) {
+        isFirst = false;
+      }
+
+      // max left size (based on next element)
+      if (balanced && abs(laneTrbl.left - otherTrbl.right) < 10) {
+        addMax(maxTrbl, 'left', otherTrbl.left + minDimensions.width);
+      }
+
+      // min left size (based on self or nested element)
+      if (abs(laneTrbl.left - otherTrbl.left) < 5) {
+        addMin(minTrbl, 'left', otherTrbl.right - minDimensions.width);
+      }
+    }
+  });
+
+  // max top/bottom/left/right size based on flow nodes
+  var flowElements = lanesRoot.children.filter(function(s) {
+    return !s.hidden && !s.waypoints && (is(s, 'bpmn:FlowElement') || is(s, 'bpmn:Artifact'));
+  });
+
+  var padding = isHorizontalLane ? LANE_PADDING : VERTICAL_LANE_PADDING;
+
+  flowElements.forEach(function(flowElement) {
+
+    var flowElementTrbl = asTRBL(flowElement);
+
+    if (isFirst && /n/.test(resizeDirection)) {
+      addMin(minTrbl, 'top', flowElementTrbl.top - padding.top);
+    }
+
+    if (isLast && /e/.test(resizeDirection)) {
+      addMax(minTrbl, 'right', flowElementTrbl.right + padding.right);
+    }
+
+    if (isLast && /s/.test(resizeDirection)) {
+      addMax(minTrbl, 'bottom', flowElementTrbl.bottom + padding.bottom);
+    }
+
+    if (isFirst && /w/.test(resizeDirection)) {
+      addMin(minTrbl, 'left', flowElementTrbl.left - padding.left);
+    }
+  });
+
+  return {
+    min: minTrbl,
+    max: maxTrbl
+  };
 }