@processmaker/modeler 1.30.3 → 1.31.0

package/src/components/modeler/Selection.vue

@@ -139,7 +139,9 @@ export default {
       }
       this.filterSelected();
       await this.$nextTick();
-      this.updateSelectionBox();
+      if (store.getters.isReadOnly === false) {
+        this.updateSelectionBox();
+      }
     },
     /**
      * Select or unselect an element with shift key pressed
@@ -197,7 +199,7 @@ export default {
         this.selected = this.selected.filter(item => item.id !== view.id);
       } else {
         this.selected.push(view);
-      }     
+      }
     },
     clearSelection() {
       this.initSelection();
@@ -333,7 +335,7 @@ export default {
     },
     /**
      * Prepare the conectedLinks collection
-     * @param {Array} shapes 
+     * @param {Array} shapes
      */
     prepareConectedLinks(shapes){
       const { paper } = this.paperManager;
@@ -457,7 +459,7 @@ export default {
         // remove from selection the selected flows that belongs to a selected pools
         if (shape.model.component  && flowTypes.includes(shape.model.component.node.type)) {
           const parent = shape.model.getParentCell();
-          if (parent && parent.component && parent.component.node.pool) {
+          if (parent.component && parent.component.node.pool) {
             return !selectedPoolsIds.includes(parent.component.node.pool.component.node.id);
           }
         }
@@ -484,7 +486,7 @@ export default {
       });
       if (shapes) {
         return true;
-      } 
+      }
       return false;
     },
     /**
@@ -568,7 +570,7 @@ export default {
       this.dragging = false;
       this.stopForceMove = false;
       // Readjusts the selection box, taking into consideration elements
-      // that are anchored and did not move, such as boundary events. 
+      // that are anchored and did not move, such as boundary events.
       await this.$nextTick();
       await this.paperManager.awaitScheduledUpdates();
       this.overPoolStopDrag();
@@ -606,7 +608,7 @@ export default {
         });
       }
       // allow movements only if one boundary event is selected;
-      if (this.selected && this.selected.length === 1 && 
+      if (this.selected && this.selected.length === 1 &&
         this.selected[0].model.get('type') === 'processmaker.components.nodes.boundaryEvent.Shape') {
         this.selected[0].model.translate(x, y);
         // validation about boundary event movements
@@ -713,7 +715,7 @@ export default {
     },
     /**
      * Check that they are not in a pool
-     * @param {Array} elements 
+     * @param {Array} elements
      * @return true if there is a pool in the selection or if none of the selected elements are in a pool
      */
     isNotPoolChilds(elements) {
@@ -795,7 +797,7 @@ export default {
           this.updateLaneChildren(this.selected);
           this.$emit('save-state');
         }
-        
+
       }
     },
     /**

package/src/components/nodes/endEvent/index.js

@@ -15,6 +15,43 @@ export default {
   icon: require('@/assets/toolpanel/end-event.svg'),
   label: defaultNames[id],
   rank: 30,
+  items: [
+    {
+      icon: require('@/assets/toolpanel/end-event.svg'),
+      label: defaultNames[id],
+      control: true,
+      rank: 31,
+      id: 'processmaker-modeler-end-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/message-end-event.svg'),
+      label: defaultNames['processmaker-modeler-message-end-event'],
+      control: true,
+      rank: 32,
+      id: 'processmaker-modeler-message-end-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/error-end-event.svg'),
+      label: defaultNames['processmaker-modeler-error-end-event'],
+      control: true,
+      rank: 33,
+      id: 'processmaker-modeler-error-end-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/signal-end-event.svg'),
+      label: defaultNames['processmaker-modeler-signal-end-event'],
+      control: true,
+      rank: 34,
+      id: 'processmaker-modeler-signal-end-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/terminate-end-event.svg'),
+      label: defaultNames['processmaker-modeler-terminate-end-event'],
+      control: true,
+      rank: 35,
+      id: 'processmaker-modeler-terminate-end-event',
+    },
+  ],
   definition(moddle, $t) {
     return moddle.create('bpmn:EndEvent', {
       name: $t(defaultNames[id]),

package/src/components/nodes/exclusiveGateway/index.js

@@ -15,6 +15,36 @@ export default {
   icon: require('@/assets/toolpanel/generic-gateway.svg'),
   label: 'Gateway',
   rank: 50,
+  items: [
+    {
+      icon: require('@/assets/toolpanel/exclusive-gateway.svg'),
+      label: 'Exclusive Gateway',
+      control: true,
+      rank: 51,
+      id: 'processmaker-modeler-exclusive-gateway',
+    },
+    {
+      icon: require('@/assets/toolpanel/inclusive-gateway.svg'),
+      label: 'Inclusive Gateway',
+      control: true,
+      rank: 52,
+      id: 'processmaker-modeler-inclusive-gateway',
+    },
+    {
+      icon: require('@/assets/toolpanel/parallel-gateway.svg'),
+      label: 'Parallel Gateway',
+      control: true,
+      rank: 53,
+      id: 'processmaker-modeler-parallel-gateway',
+    },
+    {
+      icon: require('@/assets/toolpanel/event-based-gateway.svg'),
+      label: 'Event Based Gateway',
+      control: true,
+      rank: 54,
+      id: 'processmaker-modeler-event-based-gateway',
+    },
+  ],
   definition(moddle, $t) {
     return moddle.create('bpmn:ExclusiveGateway', {
       name: $t(defaultNames[id]),

package/src/components/nodes/index.js

@@ -31,6 +31,7 @@ export { default as pool } from './pool';
 export { default as poolLane } from './poolLane';
 export { default as ValidationStatus } from '../validationStatus/ValidationStatus';
 export { default as Modeler } from '../modeler/Modeler';
+export { default as ModelerReadonly } from '../modeler/ModelerReadonly';
 export { default as manualTask } from './manualTask';
 export { default as boundaryTimerEvent } from './boundaryTimerEvent';
 export { default as boundaryMessageEvent } from './boundaryMessageEvent';

package/src/components/nodes/intermediateTimerEvent/index.js

@@ -17,6 +17,50 @@ export default {
   icon: require('@/assets/toolpanel/generic-intermediate-event.svg'),
   label: 'Intermediate Event',
   rank: 20,
+  items: [
+    {
+      icon: require('@/assets/toolpanel/intermediate-timer-event.svg'),
+      label: 'Intermediate Timer Event',
+      control: true,
+      rank: 21,
+      id: 'processmaker-modeler-intermediate-catch-timer-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/intermediate-signal-catch-event.svg'),
+      label: 'Intermediate Signal Catch Event',
+      control: true,
+      rank: 22,
+      id: 'processmaker-modeler-intermediate-signal-catch-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/intermediate-signal-throw-event.svg'),
+      label: 'Intermediate Signal Throw Event',
+      control: true,
+      rank: 23,
+      id: 'processmaker-modeler-intermediate-signal-throw-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/intermediate-message-catch-event.svg'),
+      label: 'Intermediate Message Catch Event',
+      control: true,
+      rank: 24,
+      id: 'processmaker-modeler-intermediate-message-catch-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/intermediate-message-throw-event.svg'),
+      label: 'Intermediate Message Throw Event',
+      control: true,
+      rank: 25,
+      id: 'processmaker-modeler-intermediate-message-throw-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/intermediate-conditional-catch-event.svg'),
+      label: 'Intermediate Conditional Catch Event',
+      control: true,
+      rank: 26,
+      id: 'processmaker-modeler-intermediate-conditional-catch-event',
+    },
+  ],
   definition(moddle, $t) {
     return moddle.create('bpmn:IntermediateCatchEvent', {
       name: $t(defaultNames[id]),

package/src/components/nodes/startEvent/index.js

@@ -13,6 +13,49 @@ export default merge(cloneDeep(baseStartEventConfig), {
   icon: require('@/assets/toolpanel/start-event.svg'),
   label: defaultNames[id],
   rank: 10,
+  items: [
+    {
+      icon: require('@/assets/toolpanel/start-event.svg'),
+      label: defaultNames[id],
+      control: true,
+      bpmnType: 'bpmn:StartEvent',
+      rank: 10,
+      id: 'processmaker-modeler-start-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/message-start-event.svg'),
+      label: defaultNames['processmaker-modeler-message-start-event'],
+      control: true,
+      bpmnType: 'bpmn:StartEvent',
+      rank: 11,
+      id: 'processmaker-modeler-message-start-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/conditional-start-event.svg'),
+      label: defaultNames['processmaker-modeler-conditional-start-event'],
+      control: true,
+      bpmnType: 'bpmn:StartEvent',
+      rank: 12,
+      id: 'processmaker-modeler-conditional-start-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/signal-start-event.svg'),
+      label: defaultNames['processmaker-modeler-signal-start-event'],
+      control: true,
+      bpmnType: 'bpmn:StartEvent',
+      rank: 13,
+      id: 'processmaker-modeler-signal-start-event',
+    },
+    {
+      icon: require('@/assets/toolpanel/timer-start-event.svg'),
+      label: defaultNames['processmaker-modeler-start-timer-event'],
+      control: true,
+      bpmnType: 'bpmn:StartEvent',
+      rank: 14,
+      id: 'processmaker-modeler-start-timer-event',
+
+    },
+  ],
   definition(moddle, $t) {
     return moddle.create('bpmn:StartEvent', {
       name: $t(defaultNames[id]),

package/src/components/nodes/task/index.js

@@ -19,6 +19,36 @@ export default {
   rank: 40,
   icon: require('@/assets/toolpanel/task.svg'),
   label: 'Task',
+  items: [
+    {
+      icon: require('@/assets/toolpanel/task.svg'),
+      label: 'Form Task',
+      control: true,
+      rank: 41,
+      id: 'processmaker-modeler-task',
+    },
+    {
+      icon: require('@/assets/toolpanel/manual-task.svg'),
+      label: 'Manual Task',
+      control: true,
+      rank: 42,
+      id: 'processmaker-modeler-manual-task',
+    },
+    {
+      icon: require('@/assets/toolpanel/script-task.svg'),
+      label: 'Script Task',
+      control: true,
+      rank: 43,
+      id: 'processmaker-modeler-script-task',
+    },
+    {
+      icon: require('@/assets/toolpanel/sub-task.svg'),
+      label: 'Sub Process',
+      control: true,
+      rank: 44,
+      id: 'processmaker-modeler-call-activity',
+    },
+  ],
   definition(moddle, $t) {
     return moddle.create('bpmn:Task', {
       name: $t(defaultNames[id]),

package/src/components/railBottom/RailBottom.vue

@@ -0,0 +1,120 @@
+<template>
+  <div class="rail-container" data-cy="rail-bottom">
+    <div
+      class="rail-left"
+      :style="[overlap ? { position: 'relative'} : { position: 'absolute' }]"
+      ref="railLeftBox"
+    >
+      <MiniPaperControl
+        :paper-manager="paperManager"
+        :graph="graph"
+      />
+
+      <ZoomControl
+        :paper-manager="paperManager"
+        ref="zoomBox"
+      />
+    </div>
+
+    <div
+      class="rail-center"
+      :style="[overlap ? { width: 'auto'} : { width: '100%'}]"
+    >
+      <UndoRedoControl
+        :is-rendering="isRendering"
+        @load-xml="$emit('load-xml')"
+        @clearSelection="$emit('clearSelection')"
+        ref="undoRedoBox"
+      />
+
+      <Controls
+        :nodeTypes="nodeTypes"
+        @onCreateElement="onCreateElementHandler"
+        @onSetCursor="onSetCursorHandler"
+        ref="controlBox"
+      />
+    </div>
+  </div>
+</template>
+
+<script>
+import { nextTick } from 'vue';
+import MiniPaperControl from '@/components/railBottom/miniPaperControl/MiniPaperControl.vue';
+import ZoomControl from '@/components/railBottom/zoomControl/ZoomControl.vue';
+import UndoRedoControl from '@/components/railBottom/undoRedoControl/UndoRedoControl.vue';
+import Controls from '@/components/railBottom/controls/Controls.vue';
+
+export default {
+  components: {
+    MiniPaperControl,
+    ZoomControl,
+    UndoRedoControl,
+    Controls,
+  },
+  props: {
+    paperManager: Object,
+    graph: Object,
+    isRendering: Boolean,
+    nodeTypes: Array,
+  },
+  data() {
+    return {
+      overlap: false,
+      widthOverlapControl: 0,
+      leftOverlapUndoRedo: 0,
+      controlObserver: null,
+    };
+  },
+  created() {
+    this.controlObserver = new ResizeObserver(this.onControlObserver);
+  },
+  methods: {
+    onCreateElementHandler(data){
+      this.$emit('onCreateElement', data);
+    },
+    onSetCursorHandler(data) {
+      this.$emit('set-cursor', data);
+    },
+    onControlObserver(entries) {
+      // Control coordinates
+      const controlEl = entries[0].target.getBoundingClientRect();
+      // Zoom coordinates
+      const zoomEl = this.$refs.zoomBox.$el.getBoundingClientRect();
+      // Undo/Redo coordinates
+      const undoRedoEl = this.$refs.undoRedoBox.$el.getBoundingClientRect();
+
+      // Checks overlapping
+      if (this.overlap) {
+        if (controlEl.width < this.widthOverlapControl) {
+          // Get the computed styles of the ZoomControl
+          const zoomStyles = window.getComputedStyle(this.$refs.zoomBox.$el);
+          // Calculate the total padding of the ZoomControl element
+          const zoomPadding = parseInt(zoomStyles.paddingLeft, 10) + parseInt(zoomStyles.paddingRight, 10);
+          // Get the computed styles of the RailLeftBox
+          const railLeftBoxStyles = window.getComputedStyle(this.$refs.railLeftBox);
+          // Calculate the total padding of the RailLeftBox element
+          const railLeftBoxPadding = parseInt(railLeftBoxStyles.paddingLeft, 10) + parseInt(railLeftBoxStyles.paddingRight, 10);
+          // Calculate the left position of the Controls element when it is overlapped with the UndoRedoControl and ZoomControl elements
+          const vLeft = this.leftOverlapUndoRedo + (this.widthOverlapControl - controlEl.width) - zoomPadding - railLeftBoxPadding;
+          // Checks if the left position of the Controls element when it is overlapped with the
+          // UndoRedoControl and ZoomControl elements is greater than the right position of the ZoomControl element
+          if (vLeft > zoomEl.right) {
+            this.overlap = false;
+          }
+        }
+      } else if (undoRedoEl.left < zoomEl.right) {
+        this.overlap = true;
+        this.widthOverlapControl = controlEl.width;
+        this.leftOverlapUndoRedo = undoRedoEl.left;
+      }
+    },
+  },
+  async mounted() {
+    await nextTick();
+
+    this.controlObserver.observe(this.$refs.controlBox.$el);
+  },
+};
+</script>
+
+<style lang="scss" scoped src="./railBottom.scss"></style>

package/src/components/railBottom/controls/Controls.vue

@@ -0,0 +1,148 @@
+<template>
+  <ul
+    v-if="controls"
+    class="control-list"
+  >
+    <li
+      v-for="item in controls"
+      :class="['control-item', {'active': selectedItem === item.type}]"
+      :id="item.id"
+      :key="item.id"
+      @click.stop="onClickHandler($event, item)"
+    >
+      <SubmenuPopper
+        :data="item"
+        @clickToSubmenu="clickToSubmenuHandler"
+        :selectedItem="selectedSubmenuItem"
+        :popperType="popperType"
+      />
+    </li>
+
+    <li class="control-item">
+      <div
+        :class="{'control-add': true, 'control-active': explorerOpen}"
+        :title="$t('Add')"
+        v-b-tooltip.hover
+        @click="toggleExplorer"
+      >
+        <inline-svg :src="plusIcon" />
+      </div>
+    </li>
+  </ul>
+</template>
+
+<script>
+import InlineSvg from 'vue-inline-svg';
+import nodeTypesStore from '@/nodeTypesStore';
+import SubmenuPopper from './SubmenuPopper/SubmenuPopper.vue';
+
+export default ({
+  components: {
+    SubmenuPopper,
+    InlineSvg,
+  },
+  props: {
+    nodeTypes: Array,
+  },
+  data() {
+    return {
+      plusIcon: require('@/assets/railBottom/plus.svg'),
+      wasClicked: false,
+      element: null,
+      selectedItem: null,
+      selectedSubmenuItem: null,
+      xOffset: 0,
+      yOffset: 0,
+      movedElement: null,
+      isDragging: false,
+      helperStyles: {
+        backgroundColor:'#ffffff',
+        position: 'absolute',
+        height: '40px',
+        width: '40px',
+        zIndex: '10',
+        opacity: '0.5',
+        pointerEvents: 'none',
+      },
+      popperType: null,
+    };
+  },
+  computed: {
+    controls() {
+      return nodeTypesStore.getters.getPinnedNodeTypes;
+    },
+    explorerOpen() {
+      return nodeTypesStore.getters.getExplorerOpen;
+    },
+  },
+  methods: {
+    clickToSubmenuHandler(data){
+      window.ProcessMaker.EventBus.$off('custom-pointerclick');
+      this.wasClicked = false;
+      this.parent = this.element;
+      this.selectedSubmenuItem = data.control.type;
+      this.onClickHandler(data.event, data.control);
+    },
+    onClickHandler(event, control) {
+      this.createDraggingHelper(event, control);
+      document.addEventListener('mousemove', this.setDraggingPosition);
+      this.setDraggingPosition(event);
+      this.wasClicked = true;
+      this.element = control;
+      this.$emit('onSetCursor', 'crosshair');
+      if (!this.parent) {
+        this.selectedItem = control.type;
+        this.popperType = control.type;
+      }
+      window.ProcessMaker.EventBus.$on('custom-pointerclick', message => {
+        window.ProcessMaker.EventBus.$off('custom-pointerclick');
+        document.removeEventListener('mousemove', this.setDraggingPosition);
+        if (this.movedElement) {
+          document.body.removeChild(this.movedElement);
+        }
+        this.popperType = null;
+        this.selectedSubmenuItem = null;
+        this.selectedItem = null;
+        this.movedElement = null;
+        this.onCreateElement(message);
+      });
+    },
+    onCreateElement(event){
+      if (this.wasClicked && this.element) {
+        if (this.parent) {
+          this.parent = null;
+        }
+        this.$emit('onCreateElement', { event, control: this.element });
+        this.$emit('onSetCursor', 'none');
+        event.preventDefault();
+        this.wasClicked = false;
+      }
+    },
+    setDraggingPosition({ pageX, pageY }) {
+      this.movedElement.style.left = `${pageX}px`;
+      this.movedElement.style.top = `${pageY}px`;
+    },
+    toggleExplorer() {
+      nodeTypesStore.commit('toggleExplorer');
+      nodeTypesStore.commit('clearFilteredNodes');
+    },
+    createDraggingHelper(event, control) {
+      if (this.movedElement) {
+        document.removeEventListener('mousemove', this.setDraggingPosition);
+        document.body.removeChild(this.movedElement);
+        this.movedElement = null;
+      }
+      const sourceElement = event.target;
+      this.movedElement = document.createElement('img');
+      Object.keys(this.helperStyles).forEach((property) => {
+        this.movedElement.style[property] = this.helperStyles[property];
+      });
+      this.movedElement.src = control.icon;
+      document.body.appendChild(this.movedElement);
+      this.xOffset = event.clientX - sourceElement.getBoundingClientRect().left;
+      this.yOffset = event.clientY - sourceElement.getBoundingClientRect().top;
+    },
+  },
+});
+</script>
+<style lang="scss" scoped src="./controls.scss"></style>