bpmn-js 0.20.6 → 0.22.1

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

@@ -1,108 +1,108 @@
-'use strict';
-
-var inherits = require('inherits');
-
-var CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');
-
-var is = require('../../../util/ModelUtil').is;
-
-var getChildLanes = require('../util/LaneUtil').getChildLanes;
-
-var eachElement = require('diagram-js/lib/util/Elements').eachElement;
-
-
-var LOW_PRIORITY = 500;
-
-
-/**
- * BPMN specific delete lane behavior
- */
-function DeleteLaneBehavior(eventBus, modeling, spaceTool) {
-
-  CommandInterceptor.call(this, eventBus);
-
-
-  function compensateLaneDelete(shape, oldParent) {
-
-    var siblings = getChildLanes(oldParent);
-
-    var topAffected = [];
-    var bottomAffected = [];
-
-    eachElement(siblings, function(element) {
-
-      if (element.y > shape.y) {
-        bottomAffected.push(element);
-      } else {
-        topAffected.push(element);
-      }
-
-      return element.children;
-    });
-
-    if (!siblings.length) {
-      return;
-    }
-
-    var offset;
-
-    if (bottomAffected.length && topAffected.length) {
-      offset = shape.height / 2;
-    } else {
-      offset = shape.height;
-    }
-
-    var topAdjustments,
-        bottomAdjustments;
-
-    if (topAffected.length) {
-      topAdjustments = spaceTool.calculateAdjustments(
-        topAffected, 'y', offset, shape.y - 10);
-
-      spaceTool.makeSpace(
-        topAdjustments.movingShapes,
-        topAdjustments.resizingShapes,
-        { x: 0, y: offset }, 's');
-    }
-
-    if (bottomAffected.length) {
-      bottomAdjustments = spaceTool.calculateAdjustments(
-        bottomAffected, 'y', -offset, shape.y + shape.height + 10);
-
-      spaceTool.makeSpace(
-        bottomAdjustments.movingShapes,
-        bottomAdjustments.resizingShapes,
-        { x: 0, y: -offset }, 'n');
-    }
-  }
-
-
-  /**
-   * Adjust sizes of other lanes after lane deletion
-   */
-  this.postExecuted('shape.delete', LOW_PRIORITY, function(event) {
-
-    var context = event.context,
-        hints = context.hints,
-        shape = context.shape,
-        oldParent = context.oldParent;
-
-    // only compensate lane deletes
-    if (!is(shape, 'bpmn:Lane')) {
-      return;
-    }
-
-    // compensate root deletes only
-    if (hints && hints.nested) {
-      return;
-    }
-
-    compensateLaneDelete(shape, oldParent);
-  });
-}
-
-DeleteLaneBehavior.$inject = [ 'eventBus', 'modeling', 'spaceTool' ];
-
-inherits(DeleteLaneBehavior, CommandInterceptor);
-
+'use strict';
+
+var inherits = require('inherits');
+
+var CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');
+
+var is = require('../../../util/ModelUtil').is;
+
+var getChildLanes = require('../util/LaneUtil').getChildLanes;
+
+var eachElement = require('diagram-js/lib/util/Elements').eachElement;
+
+
+var LOW_PRIORITY = 500;
+
+
+/**
+ * BPMN specific delete lane behavior
+ */
+function DeleteLaneBehavior(eventBus, modeling, spaceTool) {
+
+  CommandInterceptor.call(this, eventBus);
+
+
+  function compensateLaneDelete(shape, oldParent) {
+
+    var siblings = getChildLanes(oldParent);
+
+    var topAffected = [];
+    var bottomAffected = [];
+
+    eachElement(siblings, function(element) {
+
+      if (element.y > shape.y) {
+        bottomAffected.push(element);
+      } else {
+        topAffected.push(element);
+      }
+
+      return element.children;
+    });
+
+    if (!siblings.length) {
+      return;
+    }
+
+    var offset;
+
+    if (bottomAffected.length && topAffected.length) {
+      offset = shape.height / 2;
+    } else {
+      offset = shape.height;
+    }
+
+    var topAdjustments,
+        bottomAdjustments;
+
+    if (topAffected.length) {
+      topAdjustments = spaceTool.calculateAdjustments(
+        topAffected, 'y', offset, shape.y - 10);
+
+      spaceTool.makeSpace(
+        topAdjustments.movingShapes,
+        topAdjustments.resizingShapes,
+        { x: 0, y: offset }, 's');
+    }
+
+    if (bottomAffected.length) {
+      bottomAdjustments = spaceTool.calculateAdjustments(
+        bottomAffected, 'y', -offset, shape.y + shape.height + 10);
+
+      spaceTool.makeSpace(
+        bottomAdjustments.movingShapes,
+        bottomAdjustments.resizingShapes,
+        { x: 0, y: -offset }, 'n');
+    }
+  }
+
+
+  /**
+   * Adjust sizes of other lanes after lane deletion
+   */
+  this.postExecuted('shape.delete', LOW_PRIORITY, function(event) {
+
+    var context = event.context,
+        hints = context.hints,
+        shape = context.shape,
+        oldParent = context.oldParent;
+
+    // only compensate lane deletes
+    if (!is(shape, 'bpmn:Lane')) {
+      return;
+    }
+
+    // compensate root deletes only
+    if (hints && hints.nested) {
+      return;
+    }
+
+    compensateLaneDelete(shape, oldParent);
+  });
+}
+
+DeleteLaneBehavior.$inject = [ 'eventBus', 'modeling', 'spaceTool' ];
+
+inherits(DeleteLaneBehavior, CommandInterceptor);
+
 module.exports = DeleteLaneBehavior;

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

@@ -1,131 +1,165 @@
-'use strict';
-
-var inherits = require('inherits');
-
-var assign = require('lodash/object/assign');
-
-var CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');
-
-var getApproxIntersection = require('diagram-js/lib/util/LineIntersection').getApproxIntersection;
-
-function copy(obj) {
-  return assign({}, obj);
-}
-
-function getMid(bounds) {
-
-  return {
-    x: Math.round(bounds.x + bounds.width / 2),
-    y: Math.round(bounds.y + bounds.height / 2)
-  };
-}
-
-function DropOnFlow(eventBus, bpmnRules, modeling) {
-
-  CommandInterceptor.call(this, eventBus);
-
-  /**
-   * Reconnect start / end of a connection after
-   * dropping an element on a flow.
-   */
-
-  function insertShape(shape, targetFlow, position) {
-    var waypoints = targetFlow.waypoints,
-        waypointsBefore, waypointsAfter, dockingPoint, source, target, reconnected;
-
-    var intersection = getApproxIntersection(waypoints, position);
-
-    if (intersection) {
-      waypointsBefore = waypoints.slice(0, intersection.index);
-      waypointsAfter = waypoints.slice(intersection.index + (intersection.bendpoint ? 1 : 0));
-
-      dockingPoint = intersection.bendpoint ? waypoints[intersection.index] : position;
-
-      waypointsBefore.push(copy(dockingPoint));
-      waypointsAfter.unshift(copy(dockingPoint));
-    }
-
-    source = targetFlow.source;
-    target = targetFlow.target;
-
-    if (bpmnRules.canConnect(source, shape, targetFlow)) {
-      // reconnect source -> inserted shape
-      modeling.reconnectEnd(targetFlow, shape, waypointsBefore || position);
-
-      reconnected = true;
-    }
-
-    if (bpmnRules.canConnect(shape, target, targetFlow)) {
-
-      if (!reconnected) {
-        // reconnect inserted shape -> end
-        modeling.reconnectStart(targetFlow, shape, waypointsAfter || position);
-      } else {
-        modeling.connect(shape, target, { type: targetFlow.type, waypoints: waypointsAfter });
-      }
-    }
-  }
-
-  this.preExecute('elements.move', function(context) {
-
-    var parent = context.newParent,
-        shapes = context.shapes,
-        shape,
-        shapeMid,
-        delta = context.delta;
-
-    if (bpmnRules.canInsert(shapes, parent)) {
-
-      shape = shapes[0];
-      shapeMid = getMid(shape);
-
-      context.targetFlow = parent;
-      context.newParent = parent.parent;
-      context.position = {
-        x: shapeMid.x + delta.x,
-        y: shapeMid.y + delta.y
-      };
-    }
-  }, true);
-
-  this.postExecuted('elements.move', function(context) {
-
-    var shapes = context.shapes,
-        targetFlow = context.targetFlow,
-        position = context.position;
-
-    if (targetFlow) {
-      insertShape(shapes[0], targetFlow, position);
-    }
-
-  }, true);
-
-  this.preExecute('shape.create', function(context) {
-
-    var parent = context.parent,
-        shape = context.shape;
-
-    if (bpmnRules.canInsert(shape, parent)) {
-      context.targetFlow = parent;
-      context.parent = parent.parent;
-    }
-  }, true);
-
-
-  this.postExecute('shape.create', function(context) {
-
-    var shape = context.shape,
-        targetFlow = context.targetFlow,
-        position = context.position;
-
-    if (targetFlow) {
-      insertShape(shape, targetFlow, position);
-    }
-  }, true);
-}
-
-inherits(DropOnFlow, CommandInterceptor);
-
-DropOnFlow.$inject = [ 'eventBus', 'bpmnRules', 'modeling' ];
-
-module.exports = DropOnFlow;
+'use strict';
+
+var inherits = require('inherits');
+
+var assign = require('lodash/object/assign'),
+    find = require('lodash/collection/find');
+
+var CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');
+
+var getApproxIntersection = require('diagram-js/lib/util/LineIntersection').getApproxIntersection;
+
+function isPointInsideBBox(bbox, point) {
+  var x = point.x,
+      y = point.y;
+
+  return x >= bbox.x &&
+    x <= bbox.x + bbox.width &&
+    y >= bbox.y &&
+    y <= bbox.y + bbox.height;
+}
+
+function copy(obj) {
+  return assign({}, obj);
+}
+
+function getMid(bounds) {
+
+  return {
+    x: Math.round(bounds.x + bounds.width / 2),
+    y: Math.round(bounds.y + bounds.height / 2)
+  };
+}
+
+function DropOnFlow(eventBus, bpmnRules, modeling) {
+
+  CommandInterceptor.call(this, eventBus);
+
+  /**
+   * Reconnect start / end of a connection after
+   * dropping an element on a flow.
+   */
+
+  function insertShape(shape, targetFlow, position) {
+    var waypoints = targetFlow.waypoints,
+        waypointsBefore, waypointsAfter, dockingPoint, source, target, reconnected;
+
+    var intersection = getApproxIntersection(waypoints, position);
+
+    if (intersection) {
+      waypointsBefore = waypoints.slice(0, intersection.index);
+      waypointsAfter = waypoints.slice(intersection.index + (intersection.bendpoint ? 1 : 0));
+
+      dockingPoint = intersection.bendpoint ? waypoints[intersection.index] : position;
+
+      // if last waypointBefore is inside shape's bounds, ignore docking point
+      if (!isPointInsideBBox(shape, waypointsBefore[waypointsBefore.length-1])) {
+        waypointsBefore.push(copy(dockingPoint));
+      }
+
+      // if first waypointAfter is inside shape's bounds, ignore docking point
+      if (!isPointInsideBBox(shape, waypointsAfter[0])) {
+        waypointsAfter.unshift(copy(dockingPoint));
+      }
+    }
+
+    source = targetFlow.source;
+    target = targetFlow.target;
+
+    if (bpmnRules.canConnect(source, shape, targetFlow)) {
+      // reconnect source -> inserted shape
+      modeling.reconnectEnd(targetFlow, shape, waypointsBefore || position);
+
+      reconnected = true;
+    }
+
+    if (bpmnRules.canConnect(shape, target, targetFlow)) {
+
+      if (!reconnected) {
+        // reconnect inserted shape -> end
+        modeling.reconnectStart(targetFlow, shape, waypointsAfter || position);
+      } else {
+        modeling.connect(shape, target, { type: targetFlow.type, waypoints: waypointsAfter });
+      }
+    }
+  }
+
+  this.preExecute('elements.move', function(context) {
+
+    var newParent = context.newParent,
+        shapes = context.shapes,
+        delta = context.delta,
+        shape = shapes[0];
+
+    if (!shape || !newParent) {
+      return;
+    }
+
+    // if the new parent is a connection,
+    // change it to the new parent's parent
+    if (newParent && newParent.waypoints) {
+      context.newParent = newParent = newParent.parent;
+    }
+
+    var shapeMid = getMid(shape);
+    var newShapeMid = {
+      x: shapeMid.x + delta.x,
+      y: shapeMid.y + delta.y
+    };
+
+    // find a connection which intersects with the
+    // element's mid point
+    var connection = find(newParent.children, function(element) {
+      var canInsert = bpmnRules.canInsert(shapes, element);
+
+      return canInsert && getApproxIntersection(element.waypoints, newShapeMid);
+    });
+
+    if (connection) {
+      context.targetFlow = connection;
+      context.position = newShapeMid;
+    }
+
+  }, true);
+
+  this.postExecuted('elements.move', function(context) {
+
+    var shapes = context.shapes,
+        targetFlow = context.targetFlow,
+        position = context.position;
+
+    if (targetFlow) {
+      insertShape(shapes[0], targetFlow, position);
+    }
+
+  }, true);
+
+  this.preExecute('shape.create', function(context) {
+
+    var parent = context.parent,
+        shape = context.shape;
+
+    if (bpmnRules.canInsert(shape, parent)) {
+      context.targetFlow = parent;
+      context.parent = parent.parent;
+    }
+  }, true);
+
+
+  this.postExecute('shape.create', function(context) {
+
+    var shape = context.shape,
+        targetFlow = context.targetFlow,
+        position = context.position;
+
+    if (targetFlow) {
+      insertShape(shape, targetFlow, position);
+    }
+  }, true);
+}
+
+inherits(DropOnFlow, CommandInterceptor);
+
+DropOnFlow.$inject = [ 'eventBus', 'bpmnRules', 'modeling' ];
+
+module.exports = DropOnFlow;

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

@@ -1,81 +1,81 @@
-'use strict';
-
-var getMid = require('diagram-js/lib/layout/LayoutUtil').getMid;
-
-var lineIntersect = require('./util/LineIntersect');
-
-
-/**
- * Fix broken dockings after DI imports.
- *
- * @param {EventBus} eventBus
- */
-function ImportDockingFix(eventBus) {
-
-  function adjustDocking(startPoint, nextPoint, elementMid) {
-
-    var elementTop = {
-      x: elementMid.x,
-      y: elementMid.y - 50
-    };
-
-    var elementLeft = {
-      x: elementMid.x - 50,
-      y: elementMid.y
-    };
-
-    var verticalIntersect = lineIntersect(startPoint, nextPoint, elementMid, elementTop),
-        horizontalIntersect = lineIntersect(startPoint, nextPoint, elementMid, elementLeft);
-
-    // original is horizontal or vertical center cross intersection
-    var centerIntersect;
-
-    if (verticalIntersect && horizontalIntersect) {
-      if (getDistance(verticalIntersect, elementMid) > getDistance(horizontalIntersect, elementMid)) {
-        centerIntersect = horizontalIntersect;
-      } else {
-        centerIntersect = verticalIntersect;
-      }
-    } else {
-      centerIntersect = verticalIntersect || horizontalIntersect;
-    }
-
-    startPoint.original = centerIntersect;
-  }
-
-  function fixDockings(connection) {
-    var waypoints = connection.waypoints;
-
-    adjustDocking(
-      waypoints[0],
-      waypoints[1],
-      getMid(connection.source)
-    );
-
-    adjustDocking(
-      waypoints[waypoints.length - 1],
-      waypoints[waypoints.length - 2],
-      getMid(connection.target)
-    );
-  }
-
-  eventBus.on('bpmnElement.added', function(e) {
-
-    var element = e.element;
-
-    if (element.waypoints) {
-      fixDockings(element);
-    }
-  });
-}
-
-ImportDockingFix.$inject = [ 'eventBus' ];
-
-module.exports = ImportDockingFix;
-
-
-/////// helpers //////////////////////////////////
-
-function getDistance(p1, p2) {
-  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
+'use strict';
+
+var getMid = require('diagram-js/lib/layout/LayoutUtil').getMid;
+
+var lineIntersect = require('./util/LineIntersect');
+
+
+/**
+ * Fix broken dockings after DI imports.
+ *
+ * @param {EventBus} eventBus
+ */
+function ImportDockingFix(eventBus) {
+
+  function adjustDocking(startPoint, nextPoint, elementMid) {
+
+    var elementTop = {
+      x: elementMid.x,
+      y: elementMid.y - 50
+    };
+
+    var elementLeft = {
+      x: elementMid.x - 50,
+      y: elementMid.y
+    };
+
+    var verticalIntersect = lineIntersect(startPoint, nextPoint, elementMid, elementTop),
+        horizontalIntersect = lineIntersect(startPoint, nextPoint, elementMid, elementLeft);
+
+    // original is horizontal or vertical center cross intersection
+    var centerIntersect;
+
+    if (verticalIntersect && horizontalIntersect) {
+      if (getDistance(verticalIntersect, elementMid) > getDistance(horizontalIntersect, elementMid)) {
+        centerIntersect = horizontalIntersect;
+      } else {
+        centerIntersect = verticalIntersect;
+      }
+    } else {
+      centerIntersect = verticalIntersect || horizontalIntersect;
+    }
+
+    startPoint.original = centerIntersect;
+  }
+
+  function fixDockings(connection) {
+    var waypoints = connection.waypoints;
+
+    adjustDocking(
+      waypoints[0],
+      waypoints[1],
+      getMid(connection.source)
+    );
+
+    adjustDocking(
+      waypoints[waypoints.length - 1],
+      waypoints[waypoints.length - 2],
+      getMid(connection.target)
+    );
+  }
+
+  eventBus.on('bpmnElement.added', function(e) {
+
+    var element = e.element;
+
+    if (element.waypoints) {
+      fixDockings(element);
+    }
+  });
+}
+
+ImportDockingFix.$inject = [ 'eventBus' ];
+
+module.exports = ImportDockingFix;
+
+
+/////// helpers //////////////////////////////////
+
+function getDistance(p1, p2) {
+  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
 }