camunda-bpmn-js 1.3.1 → 1.4.0

package/dist/camunda-cloud-modeler.development.js

@@ -17671,7 +17671,11 @@
           ...shapeStyle({
             fill: fill,
             stroke: stroke,
-            strokeWidth: 1
+            strokeWidth: 1,
+
+            // fix for safari / chrome / firefox bug not correctly
+            // resetting stroke dash array
+            strokeDasharray: [ 10000, 1 ]
           })
         });
 
@@ -17687,7 +17691,11 @@
           ...shapeStyle({
             fill: fill,
             stroke: stroke,
-            strokeWidth: 1
+            strokeWidth: 1,
+
+            // fix for safari / chrome / firefox bug not correctly
+            // resetting stroke dash array
+            strokeDasharray: [ 10000, 1 ]
           })
         });
 
@@ -17703,7 +17711,11 @@
           ...lineStyle({
             fill: 'none',
             stroke: stroke,
-            strokeWidth: 1.5
+            strokeWidth: 1.5,
+
+            // fix for safari / chrome / firefox bug not correctly
+            // resetting stroke dash array
+            strokeDasharray: [ 10000, 1 ]
           })
         });
 
@@ -17720,7 +17732,11 @@
           ...lineStyle({
             fill: 'none',
             stroke: stroke,
-            strokeWidth: 1.5
+            strokeWidth: 1.5,
+
+            // fix for safari / chrome / firefox bug not correctly
+            // resetting stroke dash array
+            strokeDasharray: [ 10000, 1 ]
           })
         });
 
@@ -40689,16 +40705,23 @@
     var selection = this._injector.get('selection', false);
     var contextPad = this._injector.get('contextPad', false);
     var palette = this._injector.get('palette', false);
+    var popupMenu = this._injector.get('popupMenu', false);
 
     const actions = {};
 
     // append
-    if (selection && contextPad) {
+    if (selection && contextPad && palette && popupMenu && palette) {
       assign$1(actions, {
         'appendElement': function(event) {
-          contextPad.triggerEntry('append', 'click', event);
-        } }
-      );
+          const selected = selection && selection.get();
+
+          if (selected.length == 1 && !popupMenu.isEmpty(selected[0], 'bpmn-append')) {
+            contextPad.triggerEntry('append', 'click', event);
+          } else {
+            palette.triggerEntry('create', 'click', event);
+          }
+        }
+      });
     }
 
     // create
@@ -40724,7 +40747,6 @@
     this._injector = injector;
     this._keyboard = this._injector.get('keyboard', false);
     this._editorActions = this._injector.get('editorActions', false);
-    this._selection = this._injector.get('selection', false);
 
     if (this._keyboard) {
       this._injector.invoke(KeyboardBindings, this);
@@ -40748,7 +40770,6 @@
 
     var keyboard = this._keyboard;
     var editorActions = this._editorActions;
-    var selection = this._selection;
 
     // inherit default bindings
     KeyboardBindings.prototype.registerBindings.call(this, keyboard, editorActions);
@@ -40779,12 +40800,7 @@
 
       if (keyboard && keyboard.isKey([ 'a', 'A' ], event)) {
 
-        if (selection && selection.get().length == 1) {
-          editorActions && editorActions.trigger('appendElement', event);
-        } else {
-          editorActions && editorActions.trigger('createElement', event);
-        }
-
+        editorActions && editorActions.trigger('appendElement', event);
         return true;
       }
     });
@@ -40816,7 +40832,8 @@
       create,
       autoPlace,
       rules,
-      mouse
+      mouse,
+      translate
   ) {
     this._elementFactory = elementFactory;
     this._popupMenu = popupMenu;
@@ -40825,6 +40842,7 @@
     this._rules = rules;
     this._create = create;
     this._mouse = mouse;
+    this._translate = translate;
 
     this.register();
   }
@@ -40835,7 +40853,8 @@
     'create',
     'autoPlace',
     'rules',
-    'mouse'
+    'mouse',
+    'translate'
   ];
 
   /**
@@ -40854,6 +40873,8 @@
    */
   AppendMenuProvider.prototype.getPopupMenuEntries = function(element) {
     const rules = this._rules;
+    const translate = this._translate;
+
     const entries = {};
 
     if (!rules.allowed('shape.append', { element: element })) {
@@ -40877,10 +40898,13 @@
       } = option;
 
       entries[`append-${actionName}`] = {
-        label,
+        label: label && translate(label),
         className,
         description,
-        group,
+        group: group && {
+          ...group,
+          name: translate(group.name)
+        },
         search,
         rank,
         action: this._createEntryAction(element, target)
@@ -40948,7 +40972,9 @@
         event = mouse.getLastMoveEvent();
       }
 
-      return create.start(event, newElement);
+      return create.start(event, newElement, {
+        source: element
+      });
     };
 
     return {
@@ -43842,7 +43868,7 @@
 
     function activateDirectEdit(element, force) {
       if (force ||
-          isAny(element, [ 'bpmn:Task', 'bpmn:TextAnnotation' ]) ||
+          isAny(element, [ 'bpmn:Task', 'bpmn:TextAnnotation', 'bpmn:Participant' ]) ||
           isCollapsedSubProcess(element)) {
 
         directEditing.activate(element);
@@ -104990,6 +105016,288 @@
     colorPopupProvider: [ 'type', ColorPopupProvider ]
   };
 
+  /**
+   * A popup menu provider that allows to append elements with
+   * element templates.
+   */
+  function ElementTemplatesAppendProvider(
+      popupMenu, translate, elementTemplates,
+      autoPlace, create, mouse, rules) {
+
+    this._popupMenu = popupMenu;
+    this._translate = translate;
+    this._elementTemplates = elementTemplates;
+    this._autoPlace = autoPlace;
+    this._create = create;
+    this._mouse = mouse;
+    this._rules = rules;
+
+    this.register();
+  }
+
+  ElementTemplatesAppendProvider.$inject = [
+    'popupMenu',
+    'translate',
+    'elementTemplates',
+    'autoPlace',
+    'create',
+    'move',
+    'rules'
+  ];
+
+  /**
+   * Register append menu provider in the popup menu
+   */
+  ElementTemplatesAppendProvider.prototype.register = function() {
+    this._popupMenu.registerProvider('bpmn-append', this);
+  };
+
+  /**
+   * Adds the element templates to the append menu.
+   * @param {djs.model.Base} element
+   *
+   * @returns {Object}
+   */
+  ElementTemplatesAppendProvider.prototype.getPopupMenuEntries = function(element) {
+    return (entries) => {
+
+      if (!this._rules.allowed('shape.append', { element: element })) {
+        return [];
+      }
+
+      const filteredTemplates = this._filterTemplates(this._elementTemplates.getLatest());
+
+      // add template entries
+      assign$1(entries, this.getTemplateEntries(element, filteredTemplates));
+
+      return entries;
+    };
+  };
+
+  /**
+   * Get all element templates.
+   *
+   * @param {djs.model.Base} element
+   *
+   * @return {Object} element templates as menu entries
+   */
+  ElementTemplatesAppendProvider.prototype.getTemplateEntries = function(element, templates) {
+
+    const templateEntries = {};
+
+    templates.map(template => {
+
+      const {
+        icon = {},
+        category,
+      } = template;
+
+      const entryId = `append.template-${template.id}`;
+
+      const defaultGroup = {
+        id: 'templates',
+        name: this._translate('Templates')
+      };
+
+      templateEntries[entryId] = {
+        label: template.name,
+        description: template.description,
+        documentationRef: template.documentationRef,
+        imageUrl: icon.contents,
+        group: category || defaultGroup,
+        action: this._getEntryAction(element, template)
+      };
+    });
+
+    return templateEntries;
+  };
+
+  /**
+   * Filter out templates from the options.
+   *
+   * @param {Array<Object>} templates
+   *
+   * @returns {Array<Object>}
+   */
+  ElementTemplatesAppendProvider.prototype._filterTemplates = function(templates) {
+    return templates.filter(template => {
+      const {
+        appliesTo,
+        elementType
+      } = template;
+
+      const type = (elementType && elementType.value) || appliesTo[0];
+
+      // elements that can not be appended
+      if ([
+        'bpmn:StartEvent',
+        'bpmn:Participant'
+      ].includes(type)) {
+        return false;
+      }
+
+      // sequence flow templates are supported
+      // but connections are not appendable
+      if ('bpmn:SequenceFlow' === type) {
+        return false;
+      }
+
+      return true;
+    });
+  };
+
+  /**
+   * Create an action for a given template.
+   *
+   * @param {djs.model.Base} element
+   * @param {Object} template
+   *
+   * @returns {Object}
+   */
+  ElementTemplatesAppendProvider.prototype._getEntryAction = function(element, template) {
+    return {
+
+      click: () => {
+        const newElement = this._elementTemplates.createElement(template);
+        this._autoPlace.append(element, newElement);
+      },
+
+      dragstart: (event) => {
+        const newElement = this._elementTemplates.createElement(template);
+
+        if (event instanceof KeyboardEvent) {
+          event = this._mouse.getLastMoveEvent();
+        }
+
+        this._create.start(event, newElement, {
+          source: element
+        });
+      }
+    };
+  };
+
+  /**
+   * A popup menu provider that allows to create elements with
+   * element templates.
+   */
+  function ElementTemplatesCreateProvider(
+      popupMenu, translate, elementTemplates,
+      mouse, create) {
+
+    this._popupMenu = popupMenu;
+    this._translate = translate;
+    this._elementTemplates = elementTemplates;
+    this._mouse = mouse;
+    this._create = create;
+
+    this.register();
+  }
+
+  ElementTemplatesCreateProvider.$inject = [
+    'popupMenu',
+    'translate',
+    'elementTemplates',
+    'mouse',
+    'create'
+  ];
+
+  /**
+   * Register create menu provider in the popup menu
+   */
+  ElementTemplatesCreateProvider.prototype.register = function() {
+    this._popupMenu.registerProvider('bpmn-create', this);
+  };
+
+  /**
+   * Adds the element templates to the create menu.
+   * @param {djs.model.Base} element
+   *
+   * @returns {Object}
+   */
+  ElementTemplatesCreateProvider.prototype.getPopupMenuEntries = function(element) {
+    return (entries) => {
+
+      // add template entries
+      assign$1(entries, this.getTemplateEntries(element));
+
+      return entries;
+    };
+  };
+
+  /**
+   * Get all element templates.
+   *
+   * @param {djs.model.Base} element
+   *
+   * @return {Array<Object>} a list of element templates as menu entries
+   */
+  ElementTemplatesCreateProvider.prototype.getTemplateEntries = function() {
+
+    const templates = this._elementTemplates.getLatest();
+    const templateEntries = {};
+
+    templates.map(template => {
+
+      const {
+        icon = {},
+        category,
+      } = template;
+
+      const entryId = `create.template-${template.id}`;
+
+      const defaultGroup = {
+        id: 'templates',
+        name: this._translate('Templates')
+      };
+
+      templateEntries[entryId] = {
+        label: template.name,
+        description: template.description,
+        documentationRef: template.documentationRef,
+        imageUrl: icon.contents,
+        group: category || defaultGroup,
+        action: {
+          click: this._getEntryAction(template),
+          dragstart: this._getEntryAction(template)
+        }
+      };
+    });
+
+    return templateEntries;
+  };
+
+
+  ElementTemplatesCreateProvider.prototype._getEntryAction = function(template) {
+    const create = this._create;
+    const popupMenu = this._popupMenu;
+    const elementTemplates = this._elementTemplates;
+    const mouse = this._mouse;
+
+    return (event) => {
+
+      popupMenu.close();
+
+      // create the new element
+      let newElement = elementTemplates.createElement(template);
+
+      // use last mouse event if triggered via keyboard
+      if (event instanceof KeyboardEvent) {
+        event = mouse.getLastMoveEvent();
+      }
+
+      return create.start(event, newElement);
+    };
+  };
+
+  var createAppendElementTemplatesModule = {
+    __init__: [
+      'elementTemplatesAppendProvider',
+      'elementTemplatesCreateProvider'
+    ],
+    elementTemplatesAppendProvider: [ 'type', ElementTemplatesAppendProvider ],
+    elementTemplatesCreateProvider: [ 'type', ElementTemplatesCreateProvider ]
+  };
+
   var inherits_browser = {exports: {}};
 
   if (typeof Object.create === 'function') {
@@ -105571,6 +105879,7 @@
     rulesModule,
     zeebePropertiesProviderModule,
     index$1,
+    createAppendElementTemplatesModule,
     replaceModule,
     sharedReplaceModule,
     colorPickerModule