bpmn-js 9.0.0-subprocesses.0 → 9.0.0-subprocesses.1

package/lib/draw/PathMap.js

@@ -444,8 +444,8 @@ export default function PathMap() {
 
 // helpers //////////////////////
 
-// copied from https://github.com/adobe-webplatform/Snap.svg/blob/master/src/svg.js
-var tokenRegex = /\{([^}]+)\}/g,
+// copied and adjusted from https://github.com/adobe-webplatform/Snap.svg/blob/master/src/svg.js
+var tokenRegex = /\{([^{}]+)\}/g,
     objNotationRegex = /(?:(?:^|\.)(.+?)(?=\[|\.|$|\()|\[('|")(.+?)\2\])(\(\))?/g; // matches .xxxxx or ["xxxxx"] to run over object properties
 
 function replacer(all, key, obj) {

package/lib/features/auto-resize/BpmnAutoResizeProvider.js

@@ -1,4 +1,4 @@
-import { getDi, is } from '../../util/ModelUtil';
+import { is } from '../../util/ModelUtil';
 
 import inherits from 'inherits';
 
@@ -32,11 +32,8 @@ BpmnAutoResizeProvider.$inject = [
  * @return {boolean}
  */
 BpmnAutoResizeProvider.prototype.canResize = function(elements, target) {
-  if (
-    !is(target, 'bpmn:Participant') &&
-    !is(target, 'bpmn:Lane') &&
-    (!is(target, 'bpmn:SubProcess') || is(getDi(target), 'bpmndi:BPMNPlane'))
-  ) {
+
+  if (!is(target, 'bpmn:Participant') && !is(target, 'bpmn:Lane') && !(is(target, 'bpmn:SubProcess'))) {
     return false;
   }
 

package/lib/features/copy-paste/ModdleCopy.js

@@ -215,11 +215,16 @@ ModdleCopy.prototype.copyProperty = function(property, parent, propertyName) {
 
   var propertyDescriptor = this._moddle.getPropertyDescriptor(parent, propertyName);
 
-  // do NOT copy Ids and references
-  if (propertyDescriptor.isId || propertyDescriptor.isReference) {
+  // do NOT copy references
+  if (propertyDescriptor.isReference) {
     return;
   }
 
+  // copy id
+  if (propertyDescriptor.isId) {
+    return this._copyId(property, parent);
+  }
+
   // copy arrays
   if (isArray(property)) {
     return reduce(property, function(childProperties, childProperty) {
@@ -258,6 +263,18 @@ ModdleCopy.prototype.copyProperty = function(property, parent, propertyName) {
   return property;
 };
 
+ModdleCopy.prototype._copyId = function(id, element) {
+
+  // disallow if already taken
+  if (this._moddle.ids.assigned(id)) {
+    return;
+  } else {
+
+    this._moddle.ids.claim(id, element);
+    return id;
+  }
+};
+
 // helpers //////////
 
 export function getPropertyNames(descriptor, keepDefaultProperties) {

package/lib/features/modeling/BpmnFactory.js

@@ -83,11 +83,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 +109,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,
+    waypoints: 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

@@ -410,11 +410,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) {

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);
     }
   }
 
@@ -140,10 +143,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 +265,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/ResizeBehavior.js

@@ -2,7 +2,14 @@ import { is } from '../../../util/ModelUtil';
 
 import { isExpanded } from '../../../util/DiUtil';
 
-import { getParticipantResizeConstraints } from './util/ResizeUtil';
+import {
+  asTRBL
+} from 'diagram-js/lib/layout/LayoutUtil';
+
+import {
+  collectLanes,
+  getLanesRoot
+} from '../util/LaneUtil';
 
 var HIGH_PRIORITY = 1500;
 
@@ -14,7 +21,6 @@ export var SUB_PROCESS_MIN_DIMENSIONS = { width: 140, height: 120 };
 
 export var TEXT_ANNOTATION_MIN_DIMENSIONS = { width: 50, height: 30 };
 
-
 /**
  * Set minimum bounds/resize constraints on resize.
  *
@@ -45,4 +51,124 @@ export default function ResizeBehavior(eventBus) {
   });
 }
 
-ResizeBehavior.$inject = [ 'eventBus' ];
+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;
+
+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
+  };
+}

package/lib/features/modeling/behavior/util/ResizeUtil.js

@@ -1,132 +1 @@
-import { is } from '../../../../util/ModelUtil';
-
-import {
-  asTRBL
-} from 'diagram-js/lib/layout/LayoutUtil';
-
-import {
-  collectLanes,
-  getLanesRoot
-} from '../../../modeling/util/LaneUtil';
-
-import { LANE_MIN_DIMENSIONS } from '../ResizeBehavior';
-
-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;
-
-
-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
-  };
-}
+export { getParticipantResizeConstraints } from '../ResizeBehavior';

package/lib/features/replace/BpmnReplace.js

@@ -2,13 +2,15 @@ import {
   pick,
   assign,
   filter,
+  forEach,
+  isArray,
+  isUndefined,
   has
 } from 'min-dash';
 
 import {
   is,
-  getBusinessObject,
-  getDi
+  getBusinessObject
 } from '../../util/ModelUtil';
 
 import {
@@ -22,6 +24,18 @@ import {
 
 import { getPropertyNames } from '../copy-paste/ModdleCopy';
 
+function copyProperties(source, target, properties) {
+  if (!isArray(properties)) {
+    properties = [ properties ];
+  }
+
+  forEach(properties, function(property) {
+    if (!isUndefined(source[property])) {
+      target[property] = source[property];
+    }
+  });
+}
+
 
 var CUSTOM_PROPERTIES = [
   'cancelActivity',
@@ -31,8 +45,10 @@ var CUSTOM_PROPERTIES = [
   'isInterrupting'
 ];
 
-
-function toggeling(element, target) {
+/**
+ * Check if element should be collapsed or expanded.
+ */
+function shouldToggleCollapsed(element, targetElement) {
 
   var oldCollapsed = (
     element && has(element, 'collapsed') ? element.collapsed : !isExpanded(element)
@@ -40,11 +56,11 @@ function toggeling(element, target) {
 
   var targetCollapsed;
 
-  if (target && (has(target, 'collapsed') || has(target, 'isExpanded'))) {
+  if (targetElement && (has(targetElement, 'collapsed') || has(targetElement, 'isExpanded'))) {
 
     // property is explicitly set so use it
     targetCollapsed = (
-      has(target, 'collapsed') ? target.collapsed : !target.isExpanded
+      has(targetElement, 'collapsed') ? targetElement.collapsed : !targetElement.isExpanded
     );
   } else {
 
@@ -53,7 +69,6 @@ function toggeling(element, target) {
   }
 
   if (oldCollapsed !== targetCollapsed) {
-    element.collapsed = oldCollapsed;
     return true;
   }
 
@@ -61,7 +76,6 @@ function toggeling(element, target) {
 }
 
 
-
 /**
  * This module takes care of replacing BPMN elements
  */
@@ -92,15 +106,13 @@ export default function BpmnReplace(
     var type = target.type,
         oldBusinessObject = element.businessObject;
 
-    if (isSubProcess(oldBusinessObject)) {
-      if (type === 'bpmn:SubProcess') {
-        if (toggeling(element, target)) {
+    if (isSubProcess(oldBusinessObject) && type === 'bpmn:SubProcess') {
+      if (shouldToggleCollapsed(element, target)) {
 
-          // expanding or collapsing process
-          modeling.toggleCollapse(element);
+        // expanding or collapsing process
+        modeling.toggleCollapse(element);
 
-          return element;
-        }
+        return element;
       }
     }
 
@@ -109,9 +121,19 @@ export default function BpmnReplace(
     var newElement = {
       type: type,
       businessObject: newBusinessObject,
-      di: getDi(element)
     };
 
+    newElement.di = {};
+
+    // colors will be set to DI
+    copyProperties(element.di, newElement.di, [
+      'fill',
+      'stroke',
+      'background-color',
+      'border-color',
+      'color'
+    ]);
+
     var elementProps = getPropertyNames(oldBusinessObject.$descriptor),
         newElementProps = getPropertyNames(newBusinessObject.$descriptor, true),
         copyProps = intersection(elementProps, newElementProps);

package/lib/features/subprocess-navigation/SubprocessCentering.js

@@ -0,0 +1,55 @@
+var defaultPosition = { x: 100, y: 50 };
+
+export default function SubprocessCentering(eventBus, canvas) {
+  var currentPlane = 'base';
+  var positionMap = {};
+
+  eventBus.on('plane.set', function(event) {
+
+    var currentViewbox = canvas.viewbox();
+    positionMap[currentPlane] = {
+      x: currentViewbox.x,
+      y: currentViewbox.y,
+      zoom: currentViewbox.scale
+    };
+
+    var planeId = event.plane.name;
+    var storedViewbox = positionMap[planeId];
+
+    if (!storedViewbox) {
+      if (!event.plane.rootElement.isImplicit) {
+        storedViewbox = {
+          x: 0,
+          y: 0,
+          zoom: 1
+        };
+      }
+      else {
+        var currentBoundingBox = canvas.getActiveLayer().getBBox();
+        storedViewbox = {
+          x: currentBoundingBox.x - defaultPosition.x,
+          y: currentBoundingBox.y - defaultPosition.y,
+          zoom: 1
+        };
+      }
+    }
+
+    var dx = (currentViewbox.x - storedViewbox.x) * currentViewbox.scale,
+        dy = (currentViewbox.y - storedViewbox.y) * currentViewbox.scale;
+
+    if (dx !== 0 || dy !== 0) {
+      canvas.scroll({
+        dx: dx,
+        dy: dy
+      });
+    }
+
+    if (storedViewbox.zoom !== currentViewbox.scale) {
+      canvas.zoom(storedViewbox.zoom, { x: 0, y: 0 });
+    }
+
+    currentPlane = planeId;
+  });
+}
+
+SubprocessCentering.$inject = [ 'eventBus', 'canvas' ];