bpmn-js 8.8.0 → 9.0.0-subprocesses.1

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/ToggleElementCollapseBehaviour.js

@@ -3,7 +3,7 @@ import inherits from 'inherits';
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
 import {
-  getBusinessObject,
+  getDi,
   is
 } from '../../../util/ModelUtil';
 
@@ -85,11 +85,11 @@ export default function ToggleElementCollapseBehaviour(
       hideEmptyLabels(shape.children);
 
       // remove collapsed marker
-      getBusinessObject(shape).di.isExpanded = true;
+      getDi(shape).isExpanded = true;
     } else {
 
       // place collapsed marker
-      getBusinessObject(shape).di.isExpanded = false;
+      getDi(shape).isExpanded = false;
     }
   });
 
@@ -101,16 +101,16 @@ export default function ToggleElementCollapseBehaviour(
 
     // revert removing/placing collapsed marker
     if (!shape.collapsed) {
-      getBusinessObject(shape).di.isExpanded = true;
+      getDi(shape).isExpanded = true;
 
     } else {
-      getBusinessObject(shape).di.isExpanded = false;
+      getDi(shape).isExpanded = false;
     }
   });
 
   this.postExecuted([ 'shape.toggleCollapse' ], LOW_PRIORITY, function(e) {
     var shape = e.context.shape,
-        defaultSize = elementFactory._getDefaultSize(shape),
+        defaultSize = elementFactory.getDefaultSize(shape),
         newBounds;
 
     if (shape.collapsed) {

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/modeling/cmd/UpdateCanvasRootHandler.js

@@ -3,6 +3,8 @@ import {
   remove as collectionRemove
 } from 'diagram-js/lib/util/Collections';
 
+import { getDi } from '../../../util/ModelUtil';
+
 
 export default function UpdateCanvasRootHandler(canvas, modeling) {
   this._canvas = canvas;
@@ -24,7 +26,7 @@ UpdateCanvasRootHandler.prototype.execute = function(context) {
       oldRoot = canvas.getRootElement(),
       oldRootBusinessObject = oldRoot.businessObject,
       bpmnDefinitions = oldRootBusinessObject.$parent,
-      diPlane = oldRootBusinessObject.di;
+      diPlane = getDi(oldRoot);
 
   // (1) replace process old <> new root
   canvas.setRootElement(newRoot, true);
@@ -37,10 +39,10 @@ UpdateCanvasRootHandler.prototype.execute = function(context) {
   oldRootBusinessObject.$parent = null;
 
   // (3) wire di
-  oldRootBusinessObject.di = null;
+  oldRoot.di = null;
 
   diPlane.bpmnElement = newRootBusinessObject;
-  newRootBusinessObject.di = diPlane;
+  newRoot.di = diPlane;
 
   context.oldRoot = oldRoot;
 
@@ -58,7 +60,7 @@ UpdateCanvasRootHandler.prototype.revert = function(context) {
       oldRoot = context.oldRoot,
       oldRootBusinessObject = oldRoot.businessObject,
       bpmnDefinitions = newRootBusinessObject.$parent,
-      diPlane = newRootBusinessObject.di;
+      diPlane = getDi(newRoot);
 
   // (1) replace process old <> new root
   canvas.setRootElement(oldRoot, true);
@@ -71,10 +73,10 @@ UpdateCanvasRootHandler.prototype.revert = function(context) {
   oldRootBusinessObject.$parent = bpmnDefinitions;
 
   // (3) wire di
-  newRootBusinessObject.di = null;
+  newRoot.di = null;
 
   diPlane.bpmnElement = oldRootBusinessObject;
-  oldRootBusinessObject.di = diPlane;
+  oldRoot.di = diPlane;
 
   // TODO(nikku): return changed elements?
   // return [ newRoot, oldRoot ];

package/lib/features/modeling/cmd/UpdatePropertiesHandler.js

@@ -6,7 +6,8 @@ import {
 } from 'min-dash';
 
 import {
-  getBusinessObject
+  getBusinessObject,
+  getDi
 } from '../../../util/ModelUtil';
 
 var DEFAULT_FLOW = 'default',
@@ -74,7 +75,7 @@ UpdatePropertiesHandler.prototype.execute = function(context) {
 
   var businessObject = element.businessObject,
       properties = unwrapBusinessObjects(context.properties),
-      oldProperties = context.oldProperties || getProperties(businessObject, properties);
+      oldProperties = context.oldProperties || getProperties(element, properties);
 
   if (isIdChange(properties, businessObject)) {
     ids.unclaim(businessObject[ID]);
@@ -97,7 +98,7 @@ UpdatePropertiesHandler.prototype.execute = function(context) {
   }
 
   // update properties
-  setProperties(businessObject, properties);
+  setProperties(element, properties);
 
   // store old values
   context.oldProperties = oldProperties;
@@ -142,7 +143,7 @@ UpdatePropertiesHandler.prototype.revert = function(context) {
       ids = this._moddle.ids;
 
   // update properties
-  setProperties(businessObject, oldProperties);
+  setProperties(element, oldProperties);
 
   if (isIdChange(properties, businessObject)) {
     ids.unclaim(properties[ID]);
@@ -161,16 +162,19 @@ function isIdChange(properties, businessObject) {
 }
 
 
-function getProperties(businessObject, properties) {
-  var propertyNames = keys(properties);
+function getProperties(element, properties) {
+  var propertyNames = keys(properties),
+      businessObject = element.businessObject,
+      di = getDi(element);
 
   return reduce(propertyNames, function(result, key) {
 
     // handle DI separately
     if (key !== DI) {
       result[key] = businessObject.get(key);
+
     } else {
-      result[key] = getDiProperties(businessObject.di, keys(properties.di));
+      result[key] = getDiProperties(di, keys(properties.di));
     }
 
     return result;
@@ -180,23 +184,26 @@ function getProperties(businessObject, properties) {
 
 function getDiProperties(di, propertyNames) {
   return reduce(propertyNames, function(result, key) {
-    result[key] = di.get(key);
+    result[key] = di && di.get(key);
 
     return result;
   }, {});
 }
 
 
-function setProperties(businessObject, properties) {
+function setProperties(element, properties) {
+  var businessObject = element.businessObject,
+      di = getDi(element);
+
   forEach(properties, function(value, key) {
 
     if (key !== DI) {
       businessObject.set(key, value);
     } else {
 
-      // only update, if businessObject.di exists
-      if (businessObject.di) {
-        setDiProperties(businessObject.di, value);
+      // only update, if di exists
+      if (di) {
+        setDiProperties(di, value);
       }
     }
   });

package/lib/features/modeling/cmd/UpdateSemanticParentHandler.js

@@ -7,21 +7,23 @@ UpdateSemanticParentHandler.$inject = [ 'bpmnUpdater' ];
 
 UpdateSemanticParentHandler.prototype.execute = function(context) {
   var dataStoreBo = context.dataStoreBo,
+      dataStoreDi = context.dataStoreDi,
       newSemanticParent = context.newSemanticParent,
       newDiParent = context.newDiParent;
 
   context.oldSemanticParent = dataStoreBo.$parent;
-  context.oldDiParent = dataStoreBo.di.$parent;
+  context.oldDiParent = dataStoreDi.$parent;
 
   // update semantic parent
   this._bpmnUpdater.updateSemanticParent(dataStoreBo, newSemanticParent);
 
   // update DI parent
-  this._bpmnUpdater.updateDiParent(dataStoreBo.di, newDiParent);
+  this._bpmnUpdater.updateDiParent(dataStoreDi, newDiParent);
 };
 
 UpdateSemanticParentHandler.prototype.revert = function(context) {
   var dataStoreBo = context.dataStoreBo,
+      dataStoreDi = context.dataStoreDi,
       oldSemanticParent = context.oldSemanticParent,
       oldDiParent = context.oldDiParent;
 
@@ -29,6 +31,6 @@ UpdateSemanticParentHandler.prototype.revert = function(context) {
   this._bpmnUpdater.updateSemanticParent(dataStoreBo, oldSemanticParent);
 
   // update DI parent
-  this._bpmnUpdater.updateDiParent(dataStoreBo.di, oldDiParent);
+  this._bpmnUpdater.updateDiParent(dataStoreDi, oldDiParent);
 };
 

package/lib/features/palette/PaletteProvider.js

@@ -1,6 +1,7 @@
 import {
   assign
 } from 'min-dash';
+import { getDi } from '../../util/ModelUtil';
 
 
 /**
@@ -52,7 +53,8 @@ PaletteProvider.prototype.getPaletteEntries = function(element) {
       var shape = elementFactory.createShape(assign({ type: type }, options));
 
       if (options) {
-        shape.businessObject.di.isExpanded = options.isExpanded;
+        var di = getDi(shape);
+        di.isExpanded = options.isExpanded;
       }
 
       create.start(event, shape);

package/lib/features/popup-menu/ReplaceMenuProvider.js

@@ -99,7 +99,7 @@ ReplaceMenuProvider.prototype.getEntries = function(element) {
   if (is(businessObject, 'bpmn:Participant')) {
 
     entries = filter(replaceOptions.PARTICIPANT, function(entry) {
-      return isExpanded(businessObject) !== entry.target.isExpanded;
+      return isExpanded(element) !== entry.target.isExpanded;
     });
 
     return this._createEntries(element, entries);
@@ -195,7 +195,7 @@ ReplaceMenuProvider.prototype.getEntries = function(element) {
   }
 
   // expanded event sub processes
-  if (isEventSubProcess(businessObject) && isExpanded(businessObject)) {
+  if (isEventSubProcess(businessObject) && isExpanded(element)) {
 
     entries = filter(replaceOptions.EVENT_SUB_PROCESS, differentType);
 
@@ -203,7 +203,7 @@ ReplaceMenuProvider.prototype.getEntries = function(element) {
   }
 
   // expanded sub processes
-  if (is(businessObject, 'bpmn:SubProcess') && isExpanded(businessObject)) {
+  if (is(businessObject, 'bpmn:SubProcess') && isExpanded(element)) {
 
     entries = filter(replaceOptions.SUBPROCESS_EXPANDED, differentType);
 
@@ -211,7 +211,7 @@ ReplaceMenuProvider.prototype.getEntries = function(element) {
   }
 
   // collapsed ad hoc sub processes
-  if (is(businessObject, 'bpmn:AdHocSubProcess') && !isExpanded(businessObject)) {
+  if (is(businessObject, 'bpmn:AdHocSubProcess') && !isExpanded(element)) {
 
     entries = filter(replaceOptions.TASK, function(entry) {
 
@@ -237,7 +237,7 @@ ReplaceMenuProvider.prototype.getEntries = function(element) {
     entries = filter(replaceOptions.TASK, differentType);
 
     // collapsed SubProcess can not be replaced with itself
-    if (is(businessObject, 'bpmn:SubProcess') && !isExpanded(businessObject)) {
+    if (is(businessObject, 'bpmn:SubProcess') && !isExpanded(element)) {
       entries = filter(entries, function(entry) {
         return entry.label !== 'Sub Process (collapsed)';
       });

package/lib/features/popup-menu/util/TypeUtil.js

@@ -36,7 +36,7 @@ export function isDifferentType(element) {
 
     var isExpandedEqual = (
       target.isExpanded === undefined ||
-      target.isExpanded === isExpanded(businessObject)
+      target.isExpanded === isExpanded(element)
     );
 
     return !isTypeEqual || !isEventDefinitionEqual || !isTriggeredByEventEqual || !isExpandedEqual;