bpmn-js 9.0.0-subprocesses.0 → 9.0.0

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

@@ -3,9 +3,7 @@ import AppendBehavior from './AppendBehavior';
 import AssociationBehavior from './AssociationBehavior';
 import AttachEventBehavior from './AttachEventBehavior';
 import BoundaryEventBehavior from './BoundaryEventBehavior';
-import RootElementReferenceBehavior from './RootElementReferenceBehavior';
 import CreateBehavior from './CreateBehavior';
-import FixHoverBehavior from './FixHoverBehavior';
 import CreateDataObjectBehavior from './CreateDataObjectBehavior';
 import CreateParticipantBehavior from './CreateParticipantBehavior';
 import DataInputAssociationBehavior from './DataInputAssociationBehavior';
@@ -14,24 +12,29 @@ import DeleteLaneBehavior from './DeleteLaneBehavior';
 import DetachEventBehavior from './DetachEventBehavior';
 import DropOnFlowBehavior from './DropOnFlowBehavior';
 import EventBasedGatewayBehavior from './EventBasedGatewayBehavior';
+import FixHoverBehavior from './FixHoverBehavior';
 import GroupBehavior from './GroupBehavior';
 import ImportDockingFix from './ImportDockingFix';
 import IsHorizontalFix from './IsHorizontalFix';
 import LabelBehavior from './LabelBehavior';
 import MessageFlowBehavior from './MessageFlowBehavior';
 import ModelingFeedback from './ModelingFeedback';
-import ReplaceConnectionBehavior from './ReplaceConnectionBehavior';
+import RemoveEmbeddedLabelBoundsBehavior from './RemoveEmbeddedLabelBoundsBehavior';
+import RemoveElementBehavior from './RemoveElementBehavior';
 import RemoveParticipantBehavior from './RemoveParticipantBehavior';
+import ReplaceConnectionBehavior from './ReplaceConnectionBehavior';
 import ReplaceElementBehaviour from './ReplaceElementBehaviour';
 import ResizeBehavior from './ResizeBehavior';
 import ResizeLaneBehavior from './ResizeLaneBehavior';
-import RemoveElementBehavior from './RemoveElementBehavior';
+import RootElementReferenceBehavior from './RootElementReferenceBehavior';
 import SpaceToolBehavior from './SpaceToolBehavior';
+import SubProcessPlaneBehavior from './SubProcessPlaneBehavior';
 import SubProcessStartEventBehavior from './SubProcessStartEventBehavior';
+import ToggleCollapseConnectionBehaviour from './ToggleCollapseConnectionBehaviour';
 import ToggleElementCollapseBehaviour from './ToggleElementCollapseBehaviour';
 import UnclaimIdBehavior from './UnclaimIdBehavior';
-import UpdateFlowNodeRefsBehavior from './UpdateFlowNodeRefsBehavior';
 import UnsetDefaultFlowBehavior from './UnsetDefaultFlowBehavior';
+import UpdateFlowNodeRefsBehavior from './UpdateFlowNodeRefsBehavior';
 
 export default {
   __init__: [
@@ -40,17 +43,16 @@ export default {
     'associationBehavior',
     'attachEventBehavior',
     'boundaryEventBehavior',
-    'rootElementReferenceBehavior',
     'createBehavior',
-    'fixHoverBehavior',
     'createDataObjectBehavior',
     'createParticipantBehavior',
-    'dataStoreBehavior',
     'dataInputAssociationBehavior',
+    'dataStoreBehavior',
     'deleteLaneBehavior',
     'detachEventBehavior',
     'dropOnFlowBehavior',
     'eventBasedGatewayBehavior',
+    'fixHoverBehavior',
     'groupBehavior',
     'importDockingFix',
     'isHorizontalFix',
@@ -58,26 +60,28 @@ export default {
     'messageFlowBehavior',
     'modelingFeedback',
     'removeElementBehavior',
+    'removeEmbeddedLabelBoundsBehavior',
     'removeParticipantBehavior',
     'replaceConnectionBehavior',
     'replaceElementBehaviour',
     'resizeBehavior',
     'resizeLaneBehavior',
-    'toggleElementCollapseBehaviour',
+    'rootElementReferenceBehavior',
     'spaceToolBehavior',
+    'subProcessPlaneBehavior',
     'subProcessStartEventBehavior',
+    'toggleCollapseConnectionBehaviour',
+    'toggleElementCollapseBehaviour',
     'unclaimIdBehavior',
-    'unsetDefaultFlowBehavior',
-    'updateFlowNodeRefsBehavior'
+    'updateFlowNodeRefsBehavior',
+    'unsetDefaultFlowBehavior'
   ],
   adaptiveLabelPositioningBehavior: [ 'type', AdaptiveLabelPositioningBehavior ],
   appendBehavior: [ 'type', AppendBehavior ],
   associationBehavior: [ 'type', AssociationBehavior ],
   attachEventBehavior: [ 'type', AttachEventBehavior ],
   boundaryEventBehavior: [ 'type', BoundaryEventBehavior ],
-  rootElementReferenceBehavior: [ 'type', RootElementReferenceBehavior ],
   createBehavior: [ 'type', CreateBehavior ],
-  fixHoverBehavior: [ 'type', FixHoverBehavior ],
   createDataObjectBehavior: [ 'type', CreateDataObjectBehavior ],
   createParticipantBehavior: [ 'type', CreateParticipantBehavior ],
   dataInputAssociationBehavior: [ 'type', DataInputAssociationBehavior ],
@@ -86,22 +90,27 @@ export default {
   detachEventBehavior: [ 'type', DetachEventBehavior ],
   dropOnFlowBehavior: [ 'type', DropOnFlowBehavior ],
   eventBasedGatewayBehavior: [ 'type', EventBasedGatewayBehavior ],
+  fixHoverBehavior: [ 'type', FixHoverBehavior ],
   groupBehavior: [ 'type', GroupBehavior ],
   importDockingFix: [ 'type', ImportDockingFix ],
   isHorizontalFix: [ 'type', IsHorizontalFix ],
   labelBehavior: [ 'type', LabelBehavior ],
   messageFlowBehavior: [ 'type', MessageFlowBehavior ],
   modelingFeedback: [ 'type', ModelingFeedback ],
-  replaceConnectionBehavior: [ 'type', ReplaceConnectionBehavior ],
+  removeElementBehavior: [ 'type', RemoveElementBehavior ],
+  removeEmbeddedLabelBoundsBehavior: ['type', RemoveEmbeddedLabelBoundsBehavior ],
   removeParticipantBehavior: [ 'type', RemoveParticipantBehavior ],
+  replaceConnectionBehavior: [ 'type', ReplaceConnectionBehavior ],
   replaceElementBehaviour: [ 'type', ReplaceElementBehaviour ],
   resizeBehavior: [ 'type', ResizeBehavior ],
   resizeLaneBehavior: [ 'type', ResizeLaneBehavior ],
-  removeElementBehavior: [ 'type', RemoveElementBehavior ],
-  toggleElementCollapseBehaviour : [ 'type', ToggleElementCollapseBehaviour ],
+  rootElementReferenceBehavior: [ 'type', RootElementReferenceBehavior ],
   spaceToolBehavior: [ 'type', SpaceToolBehavior ],
+  subProcessPlaneBehavior: [ 'type', SubProcessPlaneBehavior ],
   subProcessStartEventBehavior: [ 'type', SubProcessStartEventBehavior ],
+  toggleCollapseConnectionBehaviour: [ 'type', ToggleCollapseConnectionBehaviour ],
+  toggleElementCollapseBehaviour : [ 'type', ToggleElementCollapseBehaviour ],
   unclaimIdBehavior: [ 'type', UnclaimIdBehavior ],
-  updateFlowNodeRefsBehavior: [ 'type', UpdateFlowNodeRefsBehavior ],
-  unsetDefaultFlowBehavior: [ 'type', UnsetDefaultFlowBehavior ]
+  unsetDefaultFlowBehavior: [ 'type', UnsetDefaultFlowBehavior ],
+  updateFlowNodeRefsBehavior: [ 'type', UpdateFlowNodeRefsBehavior ]
 };

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

@@ -5,6 +5,9 @@ import {
   pick
 } from 'min-dash';
 
+import {
+  getDi
+} from '../../../util/ModelUtil';
 
 var DEFAULT_COLORS = {
   fill: undefined,
@@ -63,12 +66,26 @@ SetColorHandler.prototype.postExecute = function(context) {
     // TODO @barmac: remove once we drop bpmn.io properties
     ensureLegacySupport(assignedDi);
 
-    self._commandStack.execute('element.updateProperties', {
-      element: element,
-      properties: {
-        di: assignedDi
-      }
-    });
+    if (element.labelTarget) {
+
+      // set label colors as bpmndi:BPMNLabel#color
+      self._commandStack.execute('element.updateModdleProperties', {
+        element: element,
+        moddleElement: getDi(element).label,
+        properties: {
+          color: di['background-color']
+        }
+      });
+    } else {
+
+      // set colors bpmndi:BPMNEdge or bpmndi:BPMNShape
+      self._commandStack.execute('element.updateProperties', {
+        element: element,
+        properties: {
+          di: assignedDi
+        }
+      });
+    }
   });
 
 };

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

@@ -29,7 +29,8 @@ UpdateCanvasRootHandler.prototype.execute = function(context) {
       diPlane = getDi(oldRoot);
 
   // (1) replace process old <> new root
-  canvas.setRootElement(newRoot, true);
+  canvas.setRootElement(newRoot);
+  canvas.removeRootElement(oldRoot);
 
   // (2) update root elements
   collectionAdd(bpmnDefinitions.rootElements, newRootBusinessObject);
@@ -63,7 +64,8 @@ UpdateCanvasRootHandler.prototype.revert = function(context) {
       diPlane = getDi(newRoot);
 
   // (1) replace process old <> new root
-  canvas.setRootElement(oldRoot, true);
+  canvas.setRootElement(oldRoot);
+  canvas.removeRootElement(newRoot);
 
   // (2) update root elements
   collectionRemove(bpmnDefinitions.rootElements, newRootBusinessObject);

package/lib/features/modeling/util/ModelingUtil.js

@@ -1,24 +1,6 @@
-import {
-  some
-} from 'min-dash';
-
-import { is } from '../../../util/ModelUtil';
-
-
-/**
- * Return true if element has any of the given types.
- *
- * @param {djs.model.Base} element
- * @param {Array<string>} types
- *
- * @return {boolean}
- */
-export function isAny(element, types) {
-  return some(types, function(t) {
-    return is(element, t);
-  });
-}
+export { is, isAny } from '../../../util/ModelUtil';
 
+import { isAny } from '../../../util/ModelUtil';
 
 /**
  * Return the parent of the element with any of the given types.

package/lib/features/ordering/BpmnOrderingProvider.js

@@ -42,7 +42,7 @@ export default function BpmnOrderingProvider(eventBus, canvas, translate) {
         level: 9,
         containers: [
           'bpmn:Collaboration',
-          'bpmn:Process'
+          'bpmn:FlowElementsContainer'
         ]
       }
     },
@@ -70,7 +70,7 @@ export default function BpmnOrderingProvider(eventBus, canvas, translate) {
         level: 10,
         containers: [
           'bpmn:Collaboration',
-          'bpmn:Process'
+          'bpmn:FlowElementsContainer'
         ]
       }
     },
@@ -131,7 +131,7 @@ export default function BpmnOrderingProvider(eventBus, canvas, translate) {
     // render labels always on top
     if (element.labelTarget) {
       return {
-        parent: canvas.getRootElement(),
+        parent: canvas.findRoot(element.labelTarget) || canvas.getRootElement(),
         index: -1
       };
     }

package/lib/features/palette/PaletteProvider.js

@@ -90,7 +90,7 @@ PaletteProvider.prototype.getPaletteEntries = function(element) {
 
     create.start(event, [ subProcess, startEvent ], {
       hints: {
-        autoSelect: [ startEvent ]
+        autoSelect: [ subProcess ]
       }
     });
   }

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

@@ -83,7 +83,7 @@ ReplaceMenuProvider.prototype.getEntries = function(element) {
     return this._createEntries(element, replaceOptions.DATA_OBJECT_REFERENCE);
   }
 
-  if (is(businessObject, 'bpmn:DataStoreReference')) {
+  if (is(businessObject, 'bpmn:DataStoreReference') && !is(element.parent, 'bpmn:Collaboration')) {
     return this._createEntries(element, replaceOptions.DATA_STORE_REFERENCE);
   }
 

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/import/BpmnImporter.js

@@ -26,6 +26,13 @@ import {
 } from './Util';
 
 
+/**
+ * @param {ModdleElement} semantic
+ * @param {ModdleElement} di
+ * @param {Object} [attrs=null]
+ *
+ * @return {Object}
+ */
 function elementData(semantic, di, attrs) {
   return assign({
     id: semantic.id,
@@ -93,28 +100,26 @@ BpmnImporter.$inject = [
  * Add bpmn element (semantic) to the canvas onto the
  * specified parent shape.
  */
-BpmnImporter.prototype.add = function(context, parentElement) {
+BpmnImporter.prototype.add = function(semantic, di, parentElement) {
   var element,
       translate = this._translate,
-      hidden,
-      semantic = context.element,
-      di = context.di;
+      hidden;
 
   var parentIndex;
 
   // ROOT ELEMENT
   // handle the special case that we deal with a
-  // invisible root element (process or collaboration)
+  // invisible root element (process, subprocess or collaboration)
   if (is(di, 'bpmndi:BPMNPlane')) {
 
-    // add a virtual element (not being drawn)
-    element = this._elementFactory.createRoot(elementData(semantic, di));
+    var attrs = is(semantic, 'bpmn:SubProcess')
+      ? { id: semantic.id + '_plane' }
+      : {};
 
-    if (this._elementRegistry.get(element.id)) {
-      element.id = element.id + '_layer';
-    }
+    // add a virtual element (not being drawn)
+    element = this._elementFactory.createRoot(elementData(semantic, di, attrs));
 
-    this._canvas.setRootElementForPlane(element, semantic.id);
+    this._canvas.addRootElement(element);
   }
 
   // SHAPE
@@ -122,6 +127,7 @@ BpmnImporter.prototype.add = function(context, parentElement) {
 
     var collapsed = !isExpanded(semantic, di),
         isFrame = isFrameElement(semantic);
+
     hidden = parentElement && (parentElement.hidden || parentElement.collapsed);
 
     var bounds = di.bounds;
@@ -149,7 +155,7 @@ BpmnImporter.prototype.add = function(context, parentElement) {
 
       // check whether data store is inside our outside of its semantic parent
       if (!isPointInsideBBox(parentElement, getMid(bounds))) {
-        parentElement = this._canvas.findPlane(parentElement).rootElement;
+        parentElement = this._canvas.findRoot(parentElement);
       }
     }
 
@@ -177,7 +183,7 @@ BpmnImporter.prototype.add = function(context, parentElement) {
       // are rendered correctly across different "hacks" people
       // love to model such as cross participant / sub process
       // associations
-      parentElement = this._canvas.findPlane(parentElement).rootElement;
+      parentElement = this._canvas.findRoot(parentElement);
     }
 
     // insert sequence flows behind other flow nodes (cf. #727)

package/lib/import/BpmnTreeWalker.js

@@ -76,11 +76,11 @@ export default function BpmnTreeWalker(handler, translate) {
     }
 
     // call handler
-    return handler.element({ element: element, di: diMap[element.id] }, ctx);
+    return handler.element(element, diMap[element.id], ctx);
   }
 
   function visitRoot(element, diagram) {
-    return handler.root({ element: element, di: diMap[element.id] }, diagram);
+    return handler.root(element, diMap[element.id], diagram);
   }
 
   function visitIfDi(element, ctx) {