bpmn-js 9.0.0-subprocesses.0 → 9.0.0

package/lib/features/drilldown/SubprocessCompatibility.js

@@ -0,0 +1,196 @@
+
+import { asBounds, asTRBL } from 'diagram-js/lib/layout/LayoutUtil';
+import { is } from '../../util/ModelUtil';
+
+var DEFAULT_POSITION = {
+  x: 180,
+  y: 160
+};
+
+/**
+ * Hook into `import.render.start` and create new planes for diagrams with
+ * collapsed subprocesses and all dis on the same plane.
+ *
+ * @param {eventBus} eventBus
+ * @param {moddle} moddle
+ */
+export default function SubprocessCompatibility(eventBus, moddle) {
+  this._eventBus = eventBus;
+  this._moddle = moddle;
+
+  var self = this;
+
+  eventBus.on('import.render.start', 1500, function(e, context) {
+    self.handleImport(context.definitions);
+  });
+}
+
+SubprocessCompatibility.prototype.handleImport = function(definitions) {
+  if (!definitions.diagrams) {
+    return;
+  }
+
+  var self = this;
+  this._definitions = definitions;
+  this._processToDiagramMap = {};
+
+  definitions.diagrams.forEach(function(diagram) {
+    if (!diagram.plane || !diagram.plane.bpmnElement) {
+      return;
+    }
+
+    self._processToDiagramMap[diagram.plane.bpmnElement.id] = diagram;
+  });
+
+  var newDiagrams = [];
+  definitions.diagrams.forEach(function(diagram) {
+    var createdDiagrams = self.createNewDiagrams(diagram.plane);
+    Array.prototype.push.apply(newDiagrams, createdDiagrams);
+  });
+
+  newDiagrams.forEach(function(diagram) {
+    self.movePlaneElementsToOrigin(diagram.plane);
+  });
+};
+
+
+/**
+ * Moves all DI elements from collapsed subprocesses to a new plane.
+ *
+ * @param {Object} plane
+ * @return {Array} new diagrams created for the collapsed subprocesses
+ */
+SubprocessCompatibility.prototype.createNewDiagrams = function(plane) {
+  var self = this;
+
+  var collapsedElements = [];
+  var elementsToMove = [];
+
+  plane.get('planeElement').forEach(function(diElement) {
+    var bo = diElement.bpmnElement;
+    var parent = bo.$parent;
+
+    if (is(bo, 'bpmn:SubProcess') && !diElement.isExpanded) {
+      collapsedElements.push(bo);
+    }
+
+    if (is(parent, 'bpmn:SubProcess') && parent !== plane.bpmnElement) {
+
+      // don't change the array while we iterate over it
+      elementsToMove.push({ diElement: diElement, parent: parent });
+    }
+  });
+
+  var newDiagrams = [];
+
+  // create new planes for all collapsed subprocesses, even when they are empty
+  collapsedElements.forEach(function(element) {
+    if (!self._processToDiagramMap[element.id]) {
+      var diagram = self.createDiagram(element);
+      self._processToDiagramMap[element.id] = diagram;
+      newDiagrams.push(diagram);
+    }
+  });
+
+  elementsToMove.forEach(function(element) {
+    var diElement = element.diElement;
+    var parent = element.parent;
+
+    // parent is expanded, get nearest collapsed parent
+    while (parent && !collapsedElements.includes(parent)) {
+      parent = parent.$parent;
+    }
+
+    // false positive, all parents are expanded
+    if (!parent) {
+      return;
+    }
+
+    var diagram = self._processToDiagramMap[parent.id];
+    self.moveToDiPlane(diElement, diagram.plane);
+  });
+
+  return newDiagrams;
+};
+
+SubprocessCompatibility.prototype.movePlaneElementsToOrigin = function(plane) {
+  var elements = plane.get('planeElement');
+
+  // get bounding box of all elements
+  var planeBounds = getPlaneBounds(plane);
+
+  var offset = {
+    x: planeBounds.x - DEFAULT_POSITION.x,
+    y: planeBounds.y - DEFAULT_POSITION.y
+  };
+
+  elements.forEach(function(diElement) {
+    if (diElement.waypoint) {
+      diElement.waypoint.forEach(function(waypoint) {
+        waypoint.x = waypoint.x - offset.x;
+        waypoint.y = waypoint.y - offset.y;
+      });
+    } else if (diElement.bounds) {
+      diElement.bounds.x = diElement.bounds.x - offset.x;
+      diElement.bounds.y = diElement.bounds.y - offset.y;
+    }
+  });
+};
+
+
+SubprocessCompatibility.prototype.moveToDiPlane = function(diElement, newPlane) {
+  var containingDiagram = findRootDiagram(diElement);
+
+  // remove DI from old Plane and add it to the new one
+  var parentPlaneElement = containingDiagram.plane.get('planeElement');
+  parentPlaneElement.splice(parentPlaneElement.indexOf(diElement), 1);
+  newPlane.get('planeElement').push(diElement);
+};
+
+
+SubprocessCompatibility.prototype.createDiagram = function(bo) {
+  var plane = this._moddle.create('bpmndi:BPMNPlane', { bpmnElement: bo });
+  var diagram = this._moddle.create('bpmndi:BPMNDiagram', {
+    plane: plane
+  });
+  plane.$parent = diagram;
+  plane.bpmnElement = bo;
+  diagram.$parent = this._definitions;
+  this._definitions.diagrams.push(diagram);
+  return diagram;
+};
+
+SubprocessCompatibility.$inject = [ 'eventBus', 'moddle' ];
+
+
+// helpers
+
+function findRootDiagram(element) {
+  if (is(element, 'bpmndi:BPMNDiagram')) {
+    return element;
+  } else {
+    return findRootDiagram(element.$parent);
+  }
+}
+
+function getPlaneBounds(plane) {
+  var planeTrbl = {
+    top: Infinity,
+    right: -Infinity,
+    bottom: -Infinity,
+    left: Infinity
+  };
+
+  plane.planeElement.forEach(function(element) {
+    if (!element.bounds) {
+      return;
+    }
+
+    var trbl = asTRBL(element.bounds);
+
+    planeTrbl.top = Math.min(trbl.top, planeTrbl.top);
+    planeTrbl.left = Math.min(trbl.left, planeTrbl.left);
+  });
+
+  return asBounds(planeTrbl);
+}

package/lib/features/drilldown/index.js

@@ -0,0 +1,17 @@
+import OverlaysModule from 'diagram-js/lib/features/overlays';
+import ChangeSupportModule from 'diagram-js/lib/features/change-support';
+import RootElementsModule from 'diagram-js/lib/features/root-elements';
+
+import DrilldownBreadcrumbs from './DrilldownBreadcrumbs';
+import DrilldownCentering from './DrilldownCentering';
+import SubprocessCompatibility from './SubprocessCompatibility';
+import DrilldownOverlayBehavior from './DrilldownOverlayBehavior';
+
+export default {
+  __depends__: [ OverlaysModule, ChangeSupportModule, RootElementsModule ],
+  __init__: [ 'drilldownBreadcrumbs', 'drilldownOverlayBehavior', 'drilldownCentering', 'subprocessCompatibility'],
+  drilldownBreadcrumbs: [ 'type', DrilldownBreadcrumbs ],
+  drilldownCentering: [ 'type', DrilldownCentering ],
+  drilldownOverlayBehavior: [ 'type', DrilldownOverlayBehavior ],
+  subprocessCompatibility: [ 'type', SubprocessCompatibility ]
+};

package/lib/features/label-editing/LabelEditingProvider.js

@@ -105,7 +105,7 @@ export default function LabelEditingProvider(
 
   function activateDirectEdit(element, force) {
     if (force ||
-        isAny(element, [ 'bpmn:Task', 'bpmn:TextAnnotation', 'bpmn:Group' ]) ||
+        isAny(element, [ 'bpmn:Task', 'bpmn:TextAnnotation' ]) ||
         isCollapsedSubProcess(element)) {
 
       directEditing.activate(element);

package/lib/features/label-editing/cmd/UpdateLabelHandler.js

@@ -11,6 +11,7 @@ import {
 } from '../../../util/LabelUtil';
 
 import {
+  getDi,
   is
 } from '../../../util/ModelUtil';
 
@@ -23,7 +24,30 @@ var NULL_DIMENSIONS = {
 /**
  * A handler that updates the text of a BPMN element.
  */
-export default function UpdateLabelHandler(modeling, textRenderer) {
+export default function UpdateLabelHandler(modeling, textRenderer, bpmnFactory) {
+
+  /**
+   * Creates an empty `diLabel` attribute for embedded labels.
+   *
+   * @param {djs.model.Base} element
+   * @param {string} text
+   */
+  function ensureInternalLabelDi(element, text) {
+    if (isLabelExternal(element)) {
+      return;
+    }
+
+    var di = getDi(element);
+
+    if (text && !di.label) {
+      di.label = bpmnFactory.create('bpmndi:BPMNLabel');
+    }
+
+    if (!text && di.label) {
+      di.label = null;
+    }
+  }
+
 
   /**
    * Set the label and return the changed elements.
@@ -42,6 +66,8 @@ export default function UpdateLabelHandler(modeling, textRenderer) {
 
     setLabel(label, text, labelTarget !== label);
 
+    ensureInternalLabelDi(element, text);
+
     return [ label, labelTarget ];
   }
 
@@ -127,7 +153,8 @@ export default function UpdateLabelHandler(modeling, textRenderer) {
 
 UpdateLabelHandler.$inject = [
   'modeling',
-  'textRenderer'
+  'textRenderer',
+  'bpmnFactory'
 ];
 
 

package/lib/features/modeling/BpmnFactory.js

@@ -42,6 +42,10 @@ BpmnFactory.prototype._needsId = function(element) {
 };
 
 BpmnFactory.prototype._ensureId = function(element) {
+  if (element.id) {
+    this._model.ids.claim(element.id, element);
+    return;
+  }
 
   // generate semantic ids for elements
   // bpmn:SequenceFlow -> SequenceFlow_ID
@@ -83,11 +87,10 @@ BpmnFactory.prototype.createDiLabel = function() {
 };
 
 
-BpmnFactory.prototype.createDiShape = function(semantic, bounds, attrs) {
-
+BpmnFactory.prototype.createDiShape = function(semantic, attrs) {
   return this.create('bpmndi:BPMNShape', assign({
     bpmnElement: semantic,
-    bounds: this.createDiBounds(bounds)
+    bounds: this.createDiBounds()
   }, attrs));
 };
 
@@ -110,14 +113,15 @@ BpmnFactory.prototype.createDiWaypoint = function(point) {
 };
 
 
-BpmnFactory.prototype.createDiEdge = function(semantic, waypoints, attrs) {
+BpmnFactory.prototype.createDiEdge = function(semantic, attrs) {
   return this.create('bpmndi:BPMNEdge', assign({
-    bpmnElement: semantic
+    bpmnElement: semantic,
+    waypoint: this.createDiWaypoints([])
   }, attrs));
 };
 
-BpmnFactory.prototype.createDiPlane = function(semantic) {
-  return this.create('bpmndi:BPMNPlane', {
+BpmnFactory.prototype.createDiPlane = function(semantic, attrs) {
+  return this.create('bpmndi:BPMNPlane', assign({
     bpmnElement: semantic
-  });
+  }, attrs));
 };

package/lib/features/modeling/BpmnUpdater.js

@@ -24,6 +24,10 @@ import {
   isAny
 } from './util/ModelingUtil';
 
+import {
+  delta
+} from 'diagram-js/lib/util/PositionUtil';
+
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
 /**
@@ -344,7 +348,18 @@ BpmnUpdater.prototype.updateParent = function(element, oldParent) {
 
 BpmnUpdater.prototype.updateBounds = function(shape) {
 
-  var di = getDi(shape);
+  var di = getDi(shape),
+      embeddedLabelBounds = getEmbeddedLabelBounds(shape);
+
+  // update embedded label bounds if possible
+  if (embeddedLabelBounds) {
+    var embeddedLabelBoundsDelta = delta(embeddedLabelBounds, di.get('bounds'));
+
+    assign(embeddedLabelBounds, {
+      x: shape.x + embeddedLabelBoundsDelta.x,
+      y: shape.y + embeddedLabelBoundsDelta.y
+    });
+  }
 
   var target = (shape instanceof Label) ? this._getLabel(di) : di;
 
@@ -410,11 +425,6 @@ BpmnUpdater.prototype.updateDiParent = function(di, parentDi) {
     return;
   }
 
-  // Cover the case where di.$parent === undefined and parentDi === null
-  if (!parentDi && !di.$parent) {
-    return;
-  }
-
   var planeElements = (parentDi || di.$parent).get('planeElement');
 
   if (parentDi) {
@@ -723,3 +733,30 @@ function ifBpmn(fn) {
     }
   };
 }
+
+/**
+ * Return dc:Bounds of bpmndi:BPMNLabel if exists.
+ *
+ * @param {djs.model.shape} shape
+ *
+ * @returns {Object|undefined}
+ */
+function getEmbeddedLabelBounds(shape) {
+  if (!is(shape, 'bpmn:Activity')) {
+    return;
+  }
+
+  var di = getDi(shape);
+
+  if (!di) {
+    return;
+  }
+
+  var label = di.get('label');
+
+  if (!label) {
+    return;
+  }
+
+  return label.get('bounds');
+}

package/lib/features/modeling/ElementFactory.js

@@ -12,6 +12,10 @@ import {
   is
 } from '../../util/ModelUtil';
 
+import {
+  isAny
+} from '../modeling/util/ModelingUtil';
+
 import {
   isExpanded
 } from '../../util/DiUtil';
@@ -80,20 +84,19 @@ ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
     ensureCompatDiRef(businessObject);
   }
 
-  if (!di) {
+  if (!isModdleDi(di)) {
+    var diAttrs = assign(
+      di || {},
+      { id: businessObject.id + '_di' }
+    );
+
     if (elementType === 'root') {
-      di = this._bpmnFactory.createDiPlane(businessObject, [], {
-        id: businessObject.id + '_di'
-      });
+      di = this._bpmnFactory.createDiPlane(businessObject, diAttrs);
     } else
     if (elementType === 'connection') {
-      di = this._bpmnFactory.createDiEdge(businessObject, [], {
-        id: businessObject.id + '_di'
-      });
+      di = this._bpmnFactory.createDiEdge(businessObject, diAttrs);
     } else {
-      di = this._bpmnFactory.createDiShape(businessObject, {}, {
-        id: businessObject.id + '_di'
-      });
+      di = this._bpmnFactory.createDiShape(businessObject, diAttrs);
     }
   }
 
@@ -114,6 +117,10 @@ ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
     applyAttribute(di, attrs, 'isExpanded');
   }
 
+  if (is(businessObject, 'bpmn:SubProcess')) {
+    attrs.collapsed = !isExpanded(businessObject, di);
+  }
+
   if (is(businessObject, 'bpmn:ExclusiveGateway')) {
     di.isMarkerVisible = true;
   }
@@ -140,10 +147,11 @@ ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
   size = this.getDefaultSize(businessObject, di);
 
   attrs = assign({
-    businessObject: businessObject,
-    di: di,
     id: businessObject.id
-  }, size, attrs);
+  }, size, attrs, {
+    businessObject: businessObject,
+    di: di
+  });
 
   return this.baseCreate(elementType, attrs);
 };
@@ -261,4 +269,14 @@ function applyAttribute(element, attrs, attributeName) {
   element[attributeName] = attrs[attributeName];
 
   delete attrs[attributeName];
+}
+
+
+function isModdleDi(element) {
+  return isAny(element, [
+    'bpmndi:BPMNShape',
+    'bpmndi:BPMNEdge',
+    'bpmndi:BPMNDiagram',
+    'bpmndi:BPMNPlane',
+  ]);
 }

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

@@ -2,7 +2,7 @@ import inherits from 'inherits';
 
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
-import { is } from '../../../util/ModelUtil';
+import { getBusinessObject, is } from '../../../util/ModelUtil';
 
 import { isLabel } from '../../../util/LabelUtil';
 
@@ -88,122 +88,97 @@ export default function CreateParticipantBehavior(canvas, eventBus, modeling) {
     }
   });
 
-  function ensureCollaboration(context) {
-    var parent = context.parent,
-        collaboration;
-
+  // turn process into collaboration when creating first participant
+  function getOrCreateCollaboration() {
     var rootElement = canvas.getRootElement();
 
     if (is(rootElement, 'bpmn:Collaboration')) {
-      collaboration = rootElement;
-    } else {
-
-      // update root element by making collaboration
-      collaboration = modeling.makeCollaboration();
-
-      // re-use process when creating first participant
-      context.process = parent;
+      return rootElement;
     }
 
-    context.parent = collaboration;
+    return modeling.makeCollaboration();
   }
 
-  // turn process into collaboration before adding participant
-  this.preExecute('shape.create', function(context) {
-    var parent = context.parent,
-        shape = context.shape;
-
-    if (is(shape, 'bpmn:Participant') && is(parent, 'bpmn:Process')) {
-      ensureCollaboration(context);
-    }
-  }, true);
-
-  this.execute('shape.create', function(context) {
-    var process = context.process,
-        shape = context.shape;
-
-    if (process) {
-      context.oldProcessRef = shape.businessObject.processRef;
-
-      // re-use process when creating first participant
-      shape.businessObject.processRef = process.businessObject;
-    }
-  }, true);
+  // when creating mutliple elements through `elements.create` parent must be set to collaboration
+  // and passed to `shape.create` as hint
+  this.preExecute('elements.create', HIGH_PRIORITY, function(context) {
+    var elements = context.elements,
+        parent = context.parent,
+        participant = findParticipant(elements),
+        hints;
 
-  this.revert('shape.create', function(context) {
-    var process = context.process,
-        shape = context.shape;
+    if (participant && is(parent, 'bpmn:Process')) {
+      context.parent = getOrCreateCollaboration();
 
-    if (process) {
+      hints = context.hints = context.hints || {};
 
-      // re-use process when creating first participant
-      shape.businessObject.processRef = context.oldProcessRef;
+      hints.participant = participant;
+      hints.process = parent;
+      hints.processRef = getBusinessObject(participant).get('processRef');
     }
   }, true);
 
-  this.postExecute('shape.create', function(context) {
-    var process = context.process,
+  // when creating single shape through `shape.create` parent must be set to collaboration
+  // unless it was already set through `elements.create`
+  this.preExecute('shape.create', function(context) {
+    var parent = context.parent,
         shape = context.shape;
 
-    if (process) {
-
-      // move children from process to participant
-      var processChildren = process.children.slice();
+    if (is(shape, 'bpmn:Participant') && is(parent, 'bpmn:Process')) {
+      context.parent = getOrCreateCollaboration();
 
-      modeling.moveElements(processChildren, { x: 0, y: 0 }, shape);
+      context.process = parent;
+      context.processRef = getBusinessObject(shape).get('processRef');
     }
-
   }, true);
 
-  // turn process into collaboration when creating participants
-  this.preExecute('elements.create', HIGH_PRIORITY, function(context) {
-    var elements = context.elements,
-        parent = context.parent,
-        participant;
-
-    var hasParticipants = findParticipant(elements);
-
-    if (hasParticipants && is(parent, 'bpmn:Process')) {
-      ensureCollaboration(context);
-
-      participant = findParticipant(elements);
+  // #execute necessary because #preExecute not called on CommandStack#redo
+  this.execute('shape.create', function(context) {
+    var hints = context.hints || {},
+        process = context.process || hints.process,
+        shape = context.shape,
+        participant = hints.participant;
 
-      context.oldProcessRef = participant.businessObject.processRef;
+    // both shape.create and elements.create must be handled
+    if (process && (!participant || shape === participant)) {
 
-      // re-use process when creating first participant
-      participant.businessObject.processRef = parent.businessObject;
+      // monkey-patch process ref
+      getBusinessObject(shape).set('processRef', getBusinessObject(process));
     }
   }, true);
 
-  this.revert('elements.create', function(context) {
-    var elements = context.elements,
-        process = context.process,
-        participant;
+  this.revert('shape.create', function(context) {
+    var hints = context.hints || {},
+        process = context.process || hints.process,
+        processRef = context.processRef || hints.processRef,
+        shape = context.shape,
+        participant = hints.participant;
 
-    if (process) {
-      participant = findParticipant(elements);
+    // both shape.create and elements.create must be handled
+    if (process && (!participant || shape === participant)) {
 
-      // re-use process when creating first participant
-      participant.businessObject.processRef = context.oldProcessRef;
+      // monkey-patch process ref
+      getBusinessObject(shape).set('processRef', processRef);
     }
   }, true);
 
-  this.postExecute('elements.create', function(context) {
-    var elements = context.elements,
-        process = context.process,
-        participant;
+  this.postExecute('shape.create', function(context) {
+    var hints = context.hints || {},
+        process = context.process || context.hints.process,
+        shape = context.shape,
+        participant = hints.participant;
 
     if (process) {
-      participant = findParticipant(elements);
-
-      // move children from process to first participant
-      var processChildren = process.children.slice();
-
-      modeling.moveElements(processChildren, { x: 0, y: 0 }, participant);
+      var children = process.children.slice();
+
+      // both shape.create and elements.create must be handled
+      if (!participant) {
+        modeling.moveElements(children, { x: 0, y: 0 }, shape);
+      } else if (shape === participant) {
+        modeling.moveElements(children, { x: 0, y: 0 }, participant);
+      }
     }
-
   }, true);
-
 }
 
 CreateParticipantBehavior.$inject = [

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

@@ -59,12 +59,12 @@ export default function DropOnFlowBehavior(eventBus, bpmnRules, modeling) {
       dockingPoint = intersection.bendpoint ? waypoints[intersection.index] : mid;
 
       // if last waypointBefore is inside shape's bounds, ignore docking point
-      if (!isPointInsideBBox(shape, waypointsBefore[waypointsBefore.length-1])) {
+      if (waypointsBefore.length === 1 || !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])) {
+      if (waypointsAfter.length === 1 || !isPointInsideBBox(shape, waypointsAfter[0])) {
         waypointsAfter.unshift(copy(dockingPoint));
       }
     }