Lines Matching refs:element
146 Ids.prototype.next = function (element) { argument
147 return this._seed(element || true);
158 Ids.prototype.nextPrefixed = function (prefix, element) { argument
166 this.claim(id, element); // return
178 Ids.prototype.claim = function (id, element) { argument
179 this._seed.set(id, element || true);
1005 function closest (element, selector, checkYourSelf) { argument
1006 var currentElem = checkYourSelf ? element : element.parentNode;
1247 function ensureImported(element, target) { argument
1249 if (element.ownerDocument !== target.ownerDocument) {
1252 return target.ownerDocument.importNode(element, true);
1258 return element;
1273 function appendTo(element, target) { argument
1274 return target.appendChild(ensureImported(element, target));
1627 function remove$1(element) { argument
1628 var parent = element.parentNode;
1631 parent.removeChild(element);
1634 return element;
1647 function clear(element) { argument
1650 while ((child = element.firstChild)) {
1654 return element;
1657 function clone$1(element) { argument
1658 return element.cloneNode(true);
1728 var element;
1731 element = parse(name).firstChild;
1732 element = document.importNode(element, true);
1734 element = document.createElementNS(ns.svg, name);
1738 attr(element, attrs);
1741 return element;
1881 function set$1(element, svg) { argument
1886 clear(element);
1901 appendTo(nodes[i], element);
1906 function get$1(element) { argument
1907 var child = element.firstChild,
1922 function innerSVG(element, svg) { argument
1927 set$1(element, svg);
1932 return element;
1934 return get$1(element);
2339 element = context.element,
2342 if (self.canRender(element)) {
2344 return self.drawShape(visuals, element);
2346 return self.drawConnection(visuals, element);
2351 …s.on([ 'render.getShapePath', 'render.getConnectionPath'], renderPriority, function(evt, element) { argument
2352 if (self.canRender(element)) {
2354 return self.getShapePath(element);
2356 return self.getConnectionPath(element);
2452 return filter(elements, function(element) { argument
2454 return e !== element && getParent$1(element, e);
2460 function getParent$1(element, parent) { argument
2465 if (element === parent) {
2469 if (!element.parent) {
2473 return getParent$1(element.parent, parent);
2537 eachElement(elements, function(element, i, depth) { argument
2538 add$1(result, element, unique);
2540 var children = element.children;
2618 function handleElement(element) { argument
2620 enclosedElements[element.id] = element;
2622 if (element.waypoints) {
2625 enclosedConnections[element.id] = allConnections[element.id] = element;
2629 allShapes[element.id] = element;
2632 forEach(element.incoming, handleConnection);
2634 forEach(element.outgoing, handleConnection);
2637 return element.children;
2671 forEach(elements, function(element) { argument
2674 var bbox = element;
2675 if (element.waypoints && !stopRecursion) {
2676 bbox = getBBox(element.waypoints, true);
2725 forEach(elements, function(element) { argument
2727 var e = element;
2734 filteredElements[element.id] = element;
2737 filteredElements[element.id] = element;
2744 filteredElements[element.id] = element;
2746 filteredElements[element.id] = element;
2755 function getType(element) { argument
2757 if ('waypoints' in element) {
2761 if ('x' in element) {
2768 function isFrameElement$1(element) { argument
2770 return !!(element && element.isFrame);
2806 DefaultRenderer.prototype.drawShape = function drawShape(visuals, element) { argument
2812 width: element.width || 0,
2813 height: element.height || 0
2816 if (isFrameElement$1(element)) {
2954 function remove(collection, element) { argument
2956 if (!collection || !element) {
2960 var idx = collection.indexOf(element);
2977 function add(collection, element, idx) { argument
2979 if (!collection || !element) {
2987 var currentIdx = collection.indexOf(element);
3012 collection.splice(idx, 0, element);
3016 collection.push(element);
3030 function indexOf(collection, element) { argument
3032 if (!collection || !element) {
3036 return collection.indexOf(element);
4313 function findRoot(element) { argument
4314 while (element.parent) {
4315 element = element.parent;
4318 return element;
4502 allElements.forEach(function(element) { argument
4503 var type = getType(element);
4506 self.setRootElementForPlane(null, self.findPlane(element), true);
4508 self._removeElement(element, type);
4719 Canvas.prototype.findPlane = function(element) { argument
4720 if (typeof element === 'string') {
4721 element = this._elementRegistry.get(element);
4724 var root = findRoot(element);
4744 Canvas.prototype._updateMarker = function(element, marker, add) { argument
4747 if (!element.id) {
4748 element = this._elementRegistry.get(element);
4752 container = this._elementRegistry._elements[element.id];
4780 …this._eventBus.fire('element.marker.update', { element: element, gfx: container.gfx, marker: marke…
4800 Canvas.prototype.addMarker = function(element, marker) { argument
4801 this._updateMarker(element, marker, true);
4814 Canvas.prototype.removeMarker = function(element, marker) { argument
4815 this._updateMarker(element, marker, false);
4824 Canvas.prototype.hasMarker = function(element, marker) { argument
4825 if (!element.id) {
4826 element = this._elementRegistry.get(element);
4829 var gfx = this.getGraphics(element);
4843 Canvas.prototype.toggleMarker = function(element, marker) { argument
4844 if (this.hasMarker(element, marker)) {
4845 this.removeMarker(element, marker);
4847 this.addMarker(element, marker);
4870 Canvas.prototype.setRootElement = function(element, override) { argument
4874 return this.setRootElementForPlane(element, activePlane, override);
4876 var basePlane = this.createPlane(BASE_LAYER, element);
4895 Canvas.prototype.setRootElementForPlane = function(element, plane, override) { argument
4901 if (element) {
4902 this._ensureValid('root', element);
4915 eventBus.fire('root.remove', { element: currentRoot });
4916 eventBus.fire('root.removed', { element: currentRoot });
4921 if (element) {
4925 eventBus.fire('root.add', { element: element });
4927 elementRegistry.add(element, gfx);
4929 eventBus.fire('root.added', { element: element, gfx: gfx });
4933 this._elementRegistry.updateGraphics(element, this._svg, true);
4937 plane.rootElement = element;
4939 return element;
4944 Canvas.prototype._ensureValid = function(type, element) { argument
4945 if (!element.id) {
4949 if (this._elementRegistry.get(element.id)) {
4950 throw new Error('element with id ' + element.id + ' already exists');
4956 return typeof element[attr] !== 'undefined';
4965 Canvas.prototype._setParent = function(element, parent, parentIndex) { argument
4966 add(parent.children, element, parentIndex);
4967 element.parent = parent;
4990 Canvas.prototype._addElement = function(type, element, parent, parentIndex) { argument
4997 this._ensureValid(type, element);
4999 eventBus.fire(type + '.add', { element: element, parent: parent });
5001 this._setParent(element, parent, parentIndex);
5004 var gfx = graphicsFactory.create(type, element, parentIndex);
5006 this._elementRegistry.add(element, gfx);
5009 graphicsFactory.update(type, element, gfx);
5011 eventBus.fire(type + '.added', { element: element, gfx: gfx });
5013 return element;
5046 Canvas.prototype._removeElement = function(element, type) { argument
5052 element = elementRegistry.get(element.id || element);
5054 if (!element) {
5060 eventBus.fire(type + '.remove', { element: element });
5062 graphicsFactory.remove(element);
5065 remove(element.parent && element.parent.children, element);
5066 element.parent = null;
5068 eventBus.fire(type + '.removed', { element: element });
5070 elementRegistry.remove(element);
5072 return element;
5152 Canvas.prototype.getGraphics = function(element, secondary) { argument
5153 return this._elementRegistry.getGraphics(element, secondary);
5325 Canvas.prototype.scrollToElement = function(element, padding) { argument
5329 var targetPlane = this.findPlane(element);
5348 var elementBounds = getBBox(element),
5541 Canvas.prototype.getAbsoluteBBox = function(element) { argument
5547 if (element.waypoints) {
5548 var gfx = this.getGraphics(element);
5556 bbox = element;
5608 ElementRegistry.prototype.add = function(element, gfx, secondaryGfx) { argument
5610 var id = element.id;
5621 this._elements[id] = { element: element, gfx: gfx, secondaryGfx: secondaryGfx }; property in AnonymousFunctionf8d14cd18200._elements
5629 ElementRegistry.prototype.remove = function(element) { argument
5631 id = element.id || element,
5653 ElementRegistry.prototype.updateId = function(element, newId) { argument
5657 if (typeof element === 'string') {
5658 element = this.get(element);
5662 element: element,
5666 var gfx = this.getGraphics(element),
5667 secondaryGfx = this.getGraphics(element, true);
5669 this.remove(element);
5671 element.id = newId;
5673 this.add(element, gfx, secondaryGfx);
5722 return container && container.element;
5736 this.forEach(function(element, gfx) { argument
5737 if (fn(element, gfx)) {
5738 filtered.push(element);
5759 element = container.element,
5762 if (fn(element, gfx)) {
5763 return element;
5788 element = container.element,
5791 return fn(element, gfx);
5871 value: function(element) { argument
5872 var idx = this.indexOf(element);
5877 refs.unset(element, inverseProperty, target);
5880 return element;
5892 value: function(element) { argument
5893 return this.indexOf(element) !== -1;
5907 value: function(element, idx) { argument
5909 var currentIdx = this.indexOf(element);
5930 this.splice(idx, 0, element);
5935 refs.set(element, inverseProperty, target);
7032 GraphicsFactory.prototype._getChildrenContainer = function(element) { argument
7034 var gfx = this._elementRegistry.getGraphics(element);
7039 if (!element.parent) {
7125 GraphicsFactory.prototype.create = function(type, element, parentIndex) { argument
7126 var childrenGfx = this._getChildrenContainer(element.parent);
7127 return this._createContainer(type, childrenGfx, parentIndex, isFrameElement$1(element));
7165 GraphicsFactory.prototype.drawShape = function(visual, element) { argument
7168 return eventBus.fire('render.shape', { gfx: visual, element: element });
7171 GraphicsFactory.prototype.getShapePath = function(element) { argument
7174 return eventBus.fire('render.getShapePath', element);
7177 GraphicsFactory.prototype.drawConnection = function(visual, element) { argument
7180 return eventBus.fire('render.connection', { gfx: visual, element: element });
7189 GraphicsFactory.prototype.update = function(type, element, gfx) { argument
7192 if (!element.parent) {
7200 this.drawShape(visual, element);
7203 translate$2(gfx, element.x, element.y);
7206 this.drawConnection(visual, element);
7211 if (element.hidden) {
7218 GraphicsFactory.prototype.remove = function(element) { argument
7219 var gfx = this._elementRegistry.getGraphics(element);
8253 var element = { class in AnonymousFunctionf8d14cd1ed00
8270 this.properties.defineDescriptor(element, descriptor);
8271 this.properties.defineModel(element, this);
8272 this.properties.define(element, '$parent', { enumerable: false, writable: true });
8273 this.properties.define(element, '$instanceOf', { enumerable: false, writable: true });
8277 element[a.name] = a.value;
8279 element[key] = a;
8283 return element;
8307 Moddle.prototype.getElementDescriptor = function(element) { argument
8308 return element.$descriptor;
8317 Moddle.prototype.hasType = function(element, type) { argument
8319 type = element;
8320 element = this;
8323 var descriptor = element.$model.getElementDescriptor(element);
8331 Moddle.prototype.getPropertyDescriptor = function(element, property) { argument
8332 return this.getElementDescriptor(element).propertiesByName[property];
9434 function serializeFormat(element) { argument
9435 return element.xml && element.xml.serialize;
9438 function serializeAsType(element) { argument
9439 return serializeFormat(element) === XSI_TYPE;
9442 function serializeAsProperty(element) { argument
9443 return serializeFormat(element) === 'property';
9492 function getModdleDescriptor(element) { argument
9493 return element.$descriptor;
9536 this.addElement = function(element) { argument
9538 if (!element) {
9544 var descriptor = getModdleDescriptor(element);
9550 id = element.get(idProperty.name);
9563 elementsById[id] = element;
9619 if (this.element) {
9622 this.element = this.createReference(node);
9629 this.element.id = this.body;
9639 function ValueHandler(propertyDesc, element) { argument
9640 this.element = element;
9649 element = this.element,
9655 element.get(propertyDesc.name).push(value);
9657 element.set(propertyDesc.name, value);
9668 element = this.element;
9670 if (!element) {
9671 element = this.element = this.createElement(node);
9673 this.context.addElement(element);
9699 var element = this.element,
9700 descriptor = getModdleDescriptor(element),
9713 element = this.element,
9714 descriptor = getModdleDescriptor(element),
9719 element.set(bodyProperty.name, value);
9746 element: instance,
9757 element: instance,
9777 element: instance,
9867 ElementHandler.prototype.valueHandler = function(propertyDesc, element) { argument
9868 return new ValueHandler(propertyDesc, element);
9889 var propertyDesc, type, element, childHandler;
9892 element = this.element;
9897 return this.valueHandler(propertyDesc, element);
9906 var newElement = childHandler.element;
9913 element.get(propertyDesc.name).push(newElement);
9915 element.set(propertyDesc.name, newElement);
9920 element: element
9927 newElement.$parent = element;
9991 element = this.element;
9993 var newElement = handler.element,
9997 children = element.$children = element.$children || [];
10001 newElement.$parent = element;
10009 this.element.$body = this.body;
10152 var element = r.element;
10154 var property = getModdleDescriptor(element).propertiesByName[r.property];
10159 element: r.element,
10166 var collection = element.get(property.name),
10185 element.set(property.name, reference);
10309 var rootElement = rootHandler.element;
10488 function getSerializableProperties(element) { argument
10489 var descriptor = element.$descriptor;
10499 if (!has(element, name)) {
10503 var value = element[name];
10572 ReferenceSerializer.prototype.build = function(element) { argument
10573 this.element = element;
10580 .append('<' + this.tagName + '>' + this.element.id + '</' + this.tagName + '>')
10632 ElementSerializer.prototype.build = function(element) { argument
10633 this.element = element;
10635 var elementDescriptor = element.$descriptor,
10644 otherAttrs = this.parseGeneric(element);
10646 otherAttrs = this.parseNsAttributes(element);
10659 properties = getSerializableProperties(element);
10665 this.parseGenericAttributes(element, otherAttrs);
10692 ElementSerializer.prototype.nsAttributeName = function(element) { argument
10696 if (isString(element)) {
10697 ns = parseName(element);
10699 ns = element.ns;
10703 if (element.inherited) {
10721 ElementSerializer.prototype.parseGeneric = function(element) { argument
10728 forEach(element, function(val, key) {
10741 nonNsAttr = self.parseNsAttribute(element, key, val);
10752 ElementSerializer.prototype.parseNsAttribute = function(element, name, value) { argument
10753 var model = element.$model;
10796 ElementSerializer.prototype.parseNsAttributes = function(element, attrs) { argument
10799 var genericAttrs = element.$attrs;
10808 var nonNsAttr = self.parseNsAttribute(element, name, value);
10818 ElementSerializer.prototype.parseGenericAttributes = function(element, attributes) { argument
10835 attr.name, '=', attr.value, 'on', element,
10845 element = this.element;
10848 var value = element.get(p.name),
10930 var element = this.element,
10931 model = element.$model,
10981 element = this.element;
10985 var value = element.get(p.name);
11086 TypeSerializer.prototype.parseNsAttributes = function(element) { argument
11089 var attributes = ElementSerializer.prototype.parseNsAttributes.call(this, element);
11091 var descriptor = element.$descriptor;
11104 var pkg = element.$model.getPackage(typeNs.uri),
11266 BpmnModdle.prototype.toXML = function(element, options) { argument
11272 var result = writer.toXML(element);
14956 function is$2(element, type) { argument
14957 return element.$instanceOf(type);
14989 function handled(element) { argument
14990 handledElements[element.id] = element;
14993 function isHandled(element) { argument
14994 return handledElements[element.id];
14997 function visit(element, ctx) { argument
14999 var gfx = element.gfx;
15004 translate('already rendered {element}', { element: elementToString(element) })
15009 return handler.element(element, ctx);
15012 function visitRoot(element, diagram) { argument
15013 return handler.root(element, diagram);
15016 function visitIfDi(element, ctx) { argument
15019 var gfx = element.di && visit(element, ctx);
15021 handled(element);
15025 logError(e.message, { element: element, error: e });
15027 … console.error(translate('failed to import {element}', { element: elementToString(element) }));
15045 element: elementToString(bpmnElement)
15047 { element: bpmnElement }
15056 element: elementToString(di)
15058 { element: di }
15116 { element: elementToString(diagram) }
15339 element: elementToString(e),
15342 { element: e, context: context }
15440 root: function(element) { argument
15441 return importer.add(element);
15444 element: function(element, parentShape) { argument
15445 return importer.add(element, parentShape);
16120 this.get('elementRegistry').forEach(function(element) { argument
16121 var bo = element.businessObject;
16324 return find(definitions.diagrams, function(element) { argument
16325 return element.id === diagramId;
16438 function is$1(element, type) { argument
16439 var bo = getBusinessObject(element);
16452 function getBusinessObject(element) { argument
16453 return (element && element.businessObject) || element;
16456 function isExpanded(element) { argument
16458 if (is$1(element, 'bpmn:CallActivity')) {
16462 if (is$1(element, 'bpmn:SubProcess')) {
16463 return getBusinessObject(element).di && !!getBusinessObject(element).di.isExpanded;
16466 if (is$1(element, 'bpmn:Participant')) {
16467 return !!getBusinessObject(element).processRef;
16473 function isInterrupting(element) { argument
16474 return element && getBusinessObject(element).isInterrupting !== false;
16477 function isEventSubProcess(element) { argument
16478 return element && !!getBusinessObject(element).triggeredByEvent;
16481 function hasEventDefinition$2(element, eventType) { argument
16482 var bo = getBusinessObject(element),
16496 function hasErrorEventDefinition(element) { argument
16497 return hasEventDefinition$2(element, 'bpmn:ErrorEventDefinition');
16500 function hasEscalationEventDefinition(element) { argument
16501 return hasEventDefinition$2(element, 'bpmn:EscalationEventDefinition');
16504 function hasCompensateEventDefinition(element) { argument
16505 return hasEventDefinition$2(element, 'bpmn:CompensateEventDefinition');
16541 function getLabel(element) { argument
16542 var semantic = element.businessObject,
16557 function setLabel(element, text, isExternal) { argument
16558 var semantic = element.businessObject,
16571 return element;
16602 function isCollection(element) { argument
16603 var dataObject = element.dataObjectRef;
16605 return element.isCollection || (dataObject && dataObject.isCollection);
16608 function getDi(element) { argument
16609 return element.businessObject.di;
16612 function getSemantic(element) { argument
16613 return element.businessObject;
16619 function getFillColor(element, defaultColor) { argument
16620 var di = getDi(element);
16625 function getStrokeColor$1(element, defaultColor) { argument
16626 var di = getDi(element);
16631 function getLabelColor(element, defaultColor, defaultStrokeColor) { argument
16632 var di = getDi(element),
16636 getStrokeColor$1(element, defaultStrokeColor);
16764 attr(options.element, attrs);
16766 append(marker, options.element);
16814 element: sequenceflowEnd,
16829 element: messageflowStart,
16843 element: messageflowEnd,
16858 element: associationStart,
16874 element: associationEnd,
16890 element: conditionalflowMarker,
16905 element: conditionaldefaultflowMarker,
17044 return function(parentGfx, element) { argument
17045 return handlers[type](parentGfx, element);
17053 function renderEventContent(element, parentGfx) { argument
17055 var event = getSemantic(element);
17060 return renderer('bpmn:ParallelMultipleEventDefinition')(parentGfx, element, isThrowing);
17063 return renderer('bpmn:MultipleEventDefinition')(parentGfx, element, isThrowing);
17068 return renderer('bpmn:MessageEventDefinition')(parentGfx, element, isThrowing);
17072 return renderer('bpmn:TimerEventDefinition')(parentGfx, element, isThrowing);
17076 return renderer('bpmn:ConditionalEventDefinition')(parentGfx, element);
17080 return renderer('bpmn:SignalEventDefinition')(parentGfx, element, isThrowing);
17084 return renderer('bpmn:EscalationEventDefinition')(parentGfx, element, isThrowing);
17088 return renderer('bpmn:LinkEventDefinition')(parentGfx, element, isThrowing);
17092 return renderer('bpmn:ErrorEventDefinition')(parentGfx, element, isThrowing);
17096 return renderer('bpmn:CancelEventDefinition')(parentGfx, element, isThrowing);
17100 return renderer('bpmn:CompensateEventDefinition')(parentGfx, element, isThrowing);
17104 return renderer('bpmn:TerminateEventDefinition')(parentGfx, element, isThrowing);
17127 function renderEmbeddedLabel(parentGfx, element, align) { argument
17128 var semantic = getSemantic(element);
17131 box: element,
17135 fill: getLabelColor(element, defaultLabelColor, defaultStrokeColor)
17140 function renderExternalLabel(parentGfx, element) { argument
17145 x: element.width / 2 + element.x,
17146 y: element.height / 2 + element.y
17149 return renderLabel(parentGfx, getLabel(element), {
17156 fill: getLabelColor(element, defaultLabelColor, defaultStrokeColor)
17162 function renderLaneLabel(parentGfx, text, element) { argument
17166 width: element.height
17170 fill: getLabelColor(element, defaultLabelColor, defaultStrokeColor)
17174 var top = -1 * element.height;
17190 'bpmn:Event': function(parentGfx, element, attrs) {
17196 return drawCircle(parentGfx, element.width, element.height, attrs);
17198 'bpmn:StartEvent': function(parentGfx, element) {
17200 fill: getFillColor(element, defaultFillColor),
17201 stroke: getStrokeColor$1(element, defaultStrokeColor)
17204 var semantic = getSemantic(element);
17210 fill: getFillColor(element, defaultFillColor),
17211 stroke: getStrokeColor$1(element, defaultStrokeColor)
17215 var circle = renderer('bpmn:Event')(parentGfx, element, attrs);
17217 renderEventContent(element, parentGfx);
17221 'bpmn:MessageEventDefinition': function(parentGfx, element, isThrowing) {
17225 containerWidth: element.width,
17226 containerHeight: element.height,
17233 …var fill = isThrowing ? getStrokeColor$1(element, defaultStrokeColor) : getFillColor(element, defa…
17234 …var stroke = isThrowing ? getFillColor(element, defaultFillColor) : getStrokeColor$1(element, defa…
17244 'bpmn:TimerEventDefinition': function(parentGfx, element) {
17245 var circle = drawCircle(parentGfx, element.width, element.height, 0.2 * element.height, {
17247 fill: getFillColor(element, defaultFillColor),
17248 stroke: getStrokeColor$1(element, defaultStrokeColor)
17254 containerWidth: element.width,
17255 containerHeight: element.height,
17265 stroke: getStrokeColor$1(element, defaultStrokeColor)
17273 containerWidth: element.width,
17274 containerHeight: element.height,
17281 var width = element.width / 2;
17282 var height = element.height / 2;
17288 stroke: getStrokeColor$1(element, defaultStrokeColor)
17472 'bpmn:EndEvent': function(parentGfx, element) {
17473 var circle = renderer('bpmn:Event')(parentGfx, element, {
17475 fill: getFillColor(element, defaultFillColor),
17476 stroke: getStrokeColor$1(element, defaultStrokeColor)
17479 renderEventContent(element, parentGfx);
17483 'bpmn:TerminateEventDefinition': function(parentGfx, element) {
17484 var circle = drawCircle(parentGfx, element.width, element.height, 8, {
17486 fill: getStrokeColor$1(element, defaultStrokeColor),
17487 stroke: getStrokeColor$1(element, defaultStrokeColor)
17492 'bpmn:IntermediateEvent': function(parentGfx, element) {
17493 var outer = renderer('bpmn:Event')(parentGfx, element, {
17495 fill: getFillColor(element, defaultFillColor),
17496 stroke: getStrokeColor$1(element, defaultStrokeColor)
17500 drawCircle(parentGfx, element.width, element.height, INNER_OUTER_DIST, {
17502 fill: getFillColor(element, 'none'),
17503 stroke: getStrokeColor$1(element, defaultStrokeColor)
17506 renderEventContent(element, parentGfx);
17513 'bpmn:Activity': function(parentGfx, element, attrs) {
17521 return drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS, attrs);
17524 'bpmn:Task': function(parentGfx, element) {
17526 fill: getFillColor(element, defaultFillColor),
17527 stroke: getStrokeColor$1(element, defaultStrokeColor)
17530 var rect = renderer('bpmn:Activity')(parentGfx, element, attrs);
17532 renderEmbeddedLabel(parentGfx, element, 'center-middle');
17533 attachTaskMarkers(parentGfx, element);
17537 'bpmn:ServiceTask': function(parentGfx, element) {
17538 var task = renderer('bpmn:Task')(parentGfx, element);
17549 fill: getFillColor(element, defaultFillColor),
17550 stroke: getStrokeColor$1(element, defaultStrokeColor)
17562 fill: getFillColor(element, defaultFillColor)
17574 fill: getFillColor(element, defaultFillColor),
17575 stroke: getStrokeColor$1(element, defaultStrokeColor)
17580 'bpmn:UserTask': function(parentGfx, element) {
17581 var task = renderer('bpmn:Task')(parentGfx, element);
17595 fill: getFillColor(element, defaultFillColor),
17596 stroke: getStrokeColor$1(element, defaultStrokeColor)
17608 fill: getFillColor(element, defaultFillColor),
17609 stroke: getStrokeColor$1(element, defaultStrokeColor)
17621 fill: getStrokeColor$1(element, defaultStrokeColor),
17622 stroke: getStrokeColor$1(element, defaultStrokeColor)
17627 'bpmn:ManualTask': function(parentGfx, element) {
17628 var task = renderer('bpmn:Task')(parentGfx, element);
17639 fill: getFillColor(element, defaultFillColor),
17640 stroke: getStrokeColor$1(element, defaultStrokeColor)
17645 'bpmn:SendTask': function(parentGfx, element) {
17646 var task = renderer('bpmn:Task')(parentGfx, element);
17661 fill: getStrokeColor$1(element, defaultStrokeColor),
17662 stroke: getFillColor(element, defaultFillColor)
17667 'bpmn:ReceiveTask' : function(parentGfx, element) {
17668 var semantic = getSemantic(element);
17670 var task = renderer('bpmn:Task')(parentGfx, element);
17698 fill: getFillColor(element, defaultFillColor),
17699 stroke: getStrokeColor$1(element, defaultStrokeColor)
17704 'bpmn:ScriptTask': function(parentGfx, element) {
17705 var task = renderer('bpmn:Task')(parentGfx, element);
17716 stroke: getStrokeColor$1(element, defaultStrokeColor)
17721 'bpmn:BusinessRuleTask': function(parentGfx, element) {
17722 var task = renderer('bpmn:Task')(parentGfx, element);
17734 fill: getFillColor(element, '#aaaaaa'),
17735 stroke: getStrokeColor$1(element, defaultStrokeColor)
17748 stroke: getStrokeColor$1(element, defaultStrokeColor)
17753 'bpmn:SubProcess': function(parentGfx, element, attrs) {
17755 fill: getFillColor(element, defaultFillColor),
17756 stroke: getStrokeColor$1(element, defaultStrokeColor)
17759 var rect = renderer('bpmn:Activity')(parentGfx, element, attrs);
17761 var expanded = isExpanded(element);
17763 if (isEventSubProcess(element)) {
17769 renderEmbeddedLabel(parentGfx, element, expanded ? 'center-top' : 'center-middle');
17772 attachTaskMarkers(parentGfx, element);
17774 attachTaskMarkers(parentGfx, element, ['SubProcessMarker']);
17779 'bpmn:AdHocSubProcess': function(parentGfx, element) {
17780 return renderer('bpmn:SubProcess')(parentGfx, element);
17782 'bpmn:Transaction': function(parentGfx, element) {
17783 var outer = renderer('bpmn:SubProcess')(parentGfx, element);
17786 stroke: getStrokeColor$1(element, defaultStrokeColor)
17789 …/* inner path */ drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS - 2, INNER_…
17793 'bpmn:CallActivity': function(parentGfx, element) {
17794 return renderer('bpmn:SubProcess')(parentGfx, element, {
17798 'bpmn:Participant': function(parentGfx, element) {
17802 fill: getFillColor(element, defaultFillColor),
17803 stroke: getStrokeColor$1(element, defaultStrokeColor)
17806 var lane = renderer('bpmn:Lane')(parentGfx, element, attrs);
17808 var expandedPool = isExpanded(element);
17813 { x: 30, y: element.height }
17815 stroke: getStrokeColor$1(element, defaultStrokeColor)
17817 var text = getSemantic(element).name;
17818 renderLaneLabel(parentGfx, text, element);
17822 var text2 = getSemantic(element).name;
17824 box: element, align: 'center-middle',
17826 fill: getLabelColor(element, defaultLabelColor, defaultStrokeColor)
17831 var participantMultiplicity = !!(getSemantic(element).participantMultiplicity);
17834 renderer('ParticipantMultiplicityMarker')(parentGfx, element);
17839 'bpmn:Lane': function(parentGfx, element, attrs) {
17840 var rect = drawRect(parentGfx, element.width, element.height, 0, assign({
17841 fill: getFillColor(element, defaultFillColor),
17843 stroke: getStrokeColor$1(element, defaultStrokeColor)
17846 var semantic = getSemantic(element);
17850 renderLaneLabel(parentGfx, text, element);
17855 'bpmn:InclusiveGateway': function(parentGfx, element) {
17856 var diamond = renderer('bpmn:Gateway')(parentGfx, element);
17859 drawCircle(parentGfx, element.width, element.height, element.height * 0.24, {
17861 fill: getFillColor(element, defaultFillColor),
17862 stroke: getStrokeColor$1(element, defaultStrokeColor)
17867 'bpmn:ExclusiveGateway': function(parentGfx, element) {
17868 var diamond = renderer('bpmn:Gateway')(parentGfx, element);
17873 containerWidth: element.width,
17874 containerHeight: element.height,
17881 if ((getDi(element).isMarkerVisible)) {
17884 fill: getStrokeColor$1(element, defaultStrokeColor),
17885 stroke: getStrokeColor$1(element, defaultStrokeColor)
17891 'bpmn:ComplexGateway': function(parentGfx, element) {
17892 var diamond = renderer('bpmn:Gateway')(parentGfx, element);
17897 containerWidth: element.width,
17898 containerHeight: element.height,
17907 fill: getStrokeColor$1(element, defaultStrokeColor),
17908 stroke: getStrokeColor$1(element, defaultStrokeColor)
17913 'bpmn:ParallelGateway': function(parentGfx, element) {
17914 var diamond = renderer('bpmn:Gateway')(parentGfx, element);
17919 containerWidth: element.width,
17920 containerHeight: element.height,
17929 fill: getStrokeColor$1(element, defaultStrokeColor),
17930 stroke: getStrokeColor$1(element, defaultStrokeColor)
17935 'bpmn:EventBasedGateway': function(parentGfx, element) {
17937 var semantic = getSemantic(element);
17939 var diamond = renderer('bpmn:Gateway')(parentGfx, element);
17941 …/* outer circle path */ drawCircle(parentGfx, element.width, element.height, element.height * 0.20…
17944 stroke: getStrokeColor$1(element, defaultStrokeColor)
17955 containerWidth: element.width,
17956 containerHeight: element.height,
17965 fill: getFillColor(element, 'none'),
17966 stroke: getStrokeColor$1(element, defaultStrokeColor)
17977 containerWidth: element.width,
17978 containerHeight: element.height,
17993 … var innerCircle = drawCircle(parentGfx, element.width, element.height, element.height * 0.26);
17997 stroke: getStrokeColor$1(element, defaultStrokeColor)
18007 'bpmn:Gateway': function(parentGfx, element) {
18009 fill: getFillColor(element, defaultFillColor),
18011 stroke: getStrokeColor$1(element, defaultStrokeColor)
18014 return drawDiamond(parentGfx, element.width, element.height, attrs);
18016 'bpmn:SequenceFlow': function(parentGfx, element) {
18017 var pathData = createPathFromConnection(element);
18019 var fill = getFillColor(element, defaultFillColor),
18020 stroke = getStrokeColor$1(element, defaultStrokeColor);
18025 stroke: getStrokeColor$1(element, defaultStrokeColor)
18030 var sequenceFlow = getSemantic(element);
18034 if (element.source) {
18035 source = element.source.businessObject;
18055 'bpmn:Association': function(parentGfx, element, attrs) {
18057 var semantic = getSemantic(element);
18059 var fill = getFillColor(element, defaultFillColor),
18060 stroke = getStrokeColor$1(element, defaultStrokeColor);
18066 stroke: getStrokeColor$1(element, defaultStrokeColor)
18078 return drawLine(parentGfx, element.waypoints, attrs);
18080 'bpmn:DataInputAssociation': function(parentGfx, element) {
18081 var fill = getFillColor(element, defaultFillColor),
18082 stroke = getStrokeColor$1(element, defaultStrokeColor);
18084 return renderer('bpmn:Association')(parentGfx, element, {
18088 'bpmn:DataOutputAssociation': function(parentGfx, element) {
18089 var fill = getFillColor(element, defaultFillColor),
18090 stroke = getStrokeColor$1(element, defaultStrokeColor);
18092 return renderer('bpmn:Association')(parentGfx, element, {
18096 'bpmn:MessageFlow': function(parentGfx, element) {
18098 var semantic = getSemantic(element),
18099 di = getDi(element);
18101 var fill = getFillColor(element, defaultFillColor),
18102 stroke = getStrokeColor$1(element, defaultStrokeColor);
18104 var pathData = createPathFromConnection(element);
18113 stroke: getStrokeColor$1(element, defaultStrokeColor)
18145 fill: getStrokeColor$1(element, defaultLabelColor)
18161 'bpmn:DataObject': function(parentGfx, element) {
18165 containerWidth: element.width,
18166 containerHeight: element.height,
18174 fill: getFillColor(element, defaultFillColor),
18176 stroke: getStrokeColor$1(element, defaultStrokeColor)
18179 var semantic = getSemantic(element);
18182 renderDataItemCollection(parentGfx, element);
18188 'bpmn:DataInput': function(parentGfx, element) {
18193 var elementObject = renderer('bpmn:DataObject')(parentGfx, element);
18199 'bpmn:DataOutput': function(parentGfx, element) {
18203 var elementObject = renderer('bpmn:DataObject')(parentGfx, element);
18212 'bpmn:DataStoreReference': function(parentGfx, element) {
18216 containerWidth: element.width,
18217 containerHeight: element.height,
18226 fill: getFillColor(element, defaultFillColor),
18228 stroke: getStrokeColor$1(element, defaultStrokeColor)
18233 'bpmn:BoundaryEvent': function(parentGfx, element) {
18235 var semantic = getSemantic(element),
18240 fill: getFillColor(element, defaultFillColor),
18241 stroke: getStrokeColor$1(element, defaultStrokeColor)
18259 var outer = renderer('bpmn:Event')(parentGfx, element, outerAttrs);
18261 …/* inner path */ drawCircle(parentGfx, element.width, element.height, INNER_OUTER_DIST, innerAttrs…
18263 renderEventContent(element, parentGfx);
18267 'bpmn:Group': function(parentGfx, element) {
18269 var group = drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS, {
18270 stroke: getStrokeColor$1(element, defaultStrokeColor),
18279 'label': function(parentGfx, element) {
18280 return renderExternalLabel(parentGfx, element);
18282 'bpmn:TextAnnotation': function(parentGfx, element) {
18288 var textElement = drawRect(parentGfx, element.width, element.height, 0, 0, style);
18293 containerWidth: element.width,
18294 containerHeight: element.height,
18302 stroke: getStrokeColor$1(element, defaultStrokeColor)
18305 var text = getSemantic(element).text || '';
18307 box: element,
18311 fill: getLabelColor(element, defaultLabelColor, defaultStrokeColor)
18317 'ParticipantMultiplicityMarker': function(parentGfx, element) {
18321 containerWidth: element.width,
18322 containerHeight: element.height,
18324 mx: ((element.width / 2) / element.width),
18325 my: (element.height - 15) / element.height
18331 fill: getFillColor(element, defaultFillColor),
18332 stroke: getStrokeColor$1(element, defaultStrokeColor)
18335 'SubProcessMarker': function(parentGfx, element) {
18338 fill: getFillColor(element, defaultFillColor),
18339 stroke: getStrokeColor$1(element, defaultStrokeColor)
18344 translate$2(markerRect, element.width / 2 - 7.5, element.height - 20);
18349 containerWidth: element.width,
18350 containerHeight: element.height,
18352 mx: (element.width / 2 - 7.5) / element.width,
18353 my: (element.height - 20) / element.height
18358 fill: getFillColor(element, defaultFillColor),
18359 stroke: getStrokeColor$1(element, defaultStrokeColor)
18362 'ParallelMarker': function(parentGfx, element, position) {
18366 containerWidth: element.width,
18367 containerHeight: element.height,
18369 mx: ((element.width / 2 + position.parallel) / element.width),
18370 my: (element.height - 20) / element.height
18375 fill: getFillColor(element, defaultFillColor),
18376 stroke: getStrokeColor$1(element, defaultStrokeColor)
18379 'SequentialMarker': function(parentGfx, element, position) {
18383 containerWidth: element.width,
18384 containerHeight: element.height,
18386 mx: ((element.width / 2 + position.seq) / element.width),
18387 my: (element.height - 19) / element.height
18392 fill: getFillColor(element, defaultFillColor),
18393 stroke: getStrokeColor$1(element, defaultStrokeColor)
18396 'CompensationMarker': function(parentGfx, element, position) {
18400 containerWidth: element.width,
18401 containerHeight: element.height,
18403 mx: ((element.width / 2 + position.compensation) / element.width),
18404 my: (element.height - 13) / element.height
18410 fill: getFillColor(element, defaultFillColor),
18411 stroke: getStrokeColor$1(element, defaultStrokeColor)
18414 'LoopMarker': function(parentGfx, element, position) {
18418 containerWidth: element.width,
18419 containerHeight: element.height,
18421 mx: ((element.width / 2 + position.loop) / element.width),
18422 my: (element.height - 7) / element.height
18428 fill: getFillColor(element, defaultFillColor),
18429 stroke: getStrokeColor$1(element, defaultStrokeColor),
18434 'AdhocMarker': function(parentGfx, element, position) {
18438 containerWidth: element.width,
18439 containerHeight: element.height,
18441 mx: ((element.width / 2 + position.adhoc) / element.width),
18442 my: (element.height - 15) / element.height
18448 fill: getStrokeColor$1(element, defaultStrokeColor),
18449 stroke: getStrokeColor$1(element, defaultStrokeColor)
18454 function attachTaskMarkers(parentGfx, element, taskMarkers) { argument
18455 var obj = getSemantic(element);
18479 renderer(marker)(parentGfx, element, position);
18483 renderer('CompensationMarker')(parentGfx, element, position);
18487 renderer('AdhocMarker')(parentGfx, element, position);
18496 renderer('LoopMarker')(parentGfx, element, position);
18500 renderer('ParallelMarker')(parentGfx, element, position);
18504 renderer('SequentialMarker')(parentGfx, element, position);
18509 function renderDataItemCollection(parentGfx, element) { argument
18511 var yPosition = (element.height - 18) / element.height;
18516 containerWidth: element.width,
18517 containerHeight: element.height,
18548 BpmnRenderer.prototype.canRender = function(element) { argument
18549 return is$1(element, 'bpmn:BaseElement');
18552 BpmnRenderer.prototype.drawShape = function(parentGfx, element) { argument
18553 var type = element.type;
18557 return h(parentGfx, element);
18560 BpmnRenderer.prototype.drawConnection = function(parentGfx, element) { argument
18561 var type = element.type;
18565 return h(parentGfx, element);
18568 BpmnRenderer.prototype.getShapePath = function(element) { argument
18570 if (is$1(element, 'bpmn:Event')) {
18571 return getCirclePath(element);
18574 if (is$1(element, 'bpmn:Activity')) {
18575 return getRoundRectPath(element, TASK_BORDER_RADIUS);
18578 if (is$1(element, 'bpmn:Gateway')) {
18579 return getDiamondPath(element);
18582 return getRectPath(element);
18808 return this.layoutText(text, options).element;
18937 element: textElement
19603 function hasExternalLabel(element) { argument
19604 return isLabel$6(element.label);
19660 function getExternalLabelMid(element) { argument
19662 if (element.waypoints) {
19663 return getFlowLabelPosition(element.waypoints);
19664 } else if (is$1(element, 'bpmn:Group')) {
19666 x: element.x + element.width / 2,
19667 y: element.y + DEFAULT_LABEL_SIZE.height / 2
19671 x: element.x + element.width / 2,
19672 y: element.y + element.height + DEFAULT_LABEL_SIZE.height / 2
19685 function getExternalLabelBounds(semantic, element) { argument
19707 mid = getExternalLabelMid(element);
19718 function isLabel$6(element) { argument
19719 return element && !!element.labelTarget;
19745 element: elementToString(refSemantic),
19791 element,
19803 element = this._elementFactory.createRoot(elementData(semantic));
19805 this._canvas.setRootElement(element);
19817 element = this._elementFactory.createShape(elementData(semantic, {
19828 this._attachBoundary(semantic, element);
19844 this._canvas.addShape(element, parentElement, parentIndex);
19855 element = this._elementFactory.createConnection(elementData(semantic, {
19876 this._canvas.addConnection(element, parentElement, parentIndex);
19885 if (isLabelExternal(semantic) && getLabel(element)) {
19886 this.addLabel(semantic, element);
19890 this._eventBus.fire('bpmnElement.added', { element: element });
19892 return element;
19935 BpmnImporter.prototype.addLabel = function(semantic, element) { argument
19940 bounds = getExternalLabelBounds(semantic, element);
19942 text = getLabel(element);
19952 labelTarget: element,
19954 hidden: element.hidden || !getLabel(element),
19961 return this._canvas.addShape(label, element.parent);
19971 var element,
19990 element = refSemantic && this._getElement(refSemantic);
19992 if (element) {
19993 return element;
20170 function fire(type, event, element) { argument
20178 if (!element) {
20183 element = elementRegistry.get(gfx);
20186 gfx = elementRegistry.getGraphics(element);
20189 if (!gfx || !element) {
20194 element: element,
20317 var element = event.element,
20320 eventBus.fire('interactionEvents.createHit', { element: element, gfx: gfx });
20331 var element = event.element,
20334 eventBus.fire('interactionEvents.updateHit', { element: element, gfx: gfx });
20338 var element = event.element,
20341 self.createDefaultHit(element, gfx);
20345 var element = event.element,
20348 self.updateDefaultHit(element, gfx);
20418 this.createDefaultHit = function(element, gfx) { argument
20419 var waypoints = element.waypoints,
20420 isFrame = element.isFrame,
20430 width: element.width,
20431 height: element.height
20490 this.updateDefaultHit = function(element, gfx) { argument
20498 if (element.waypoints) {
20499 updateLine(hit, element.waypoints);
20502 width: element.width,
20503 height: element.height
20650 var element = event.element,
20659 self.updateShapeOutline(outline, element);
20663 var element = event.element,
20672 self.updateConnectionOutline(outline, element);
20684 Outline.prototype.updateShapeOutline = function(outline, element) { argument
20689 width: element.width + this.offset * 2,
20690 height: element.height + this.offset * 2
20742 var element = e.element;
20743 self.deselect(element);
20754 Selection.prototype.deselect = function(element) { argument
20757 var idx = selectedElements.indexOf(element);
20773 Selection.prototype.isSelected = function(element) { argument
20774 return this._selectedElements.indexOf(element) !== -1;
20799 elements = elements.filter(function(element) { argument
20800 var plane = canvas.findPlane(element);
20808 forEach(elements, function(element) { argument
20809 if (selectedElements.indexOf(element) !== -1) {
20814 selectedElements.push(element);
20853 addMarker(event.element, MARKER_HOVER);
20857 removeMarker(event.element, MARKER_HOVER);
20955 var element = event.element;
20957 if (element === canvas.getRootElement()) {
20958 element = null;
20961 var isSelected = selection.isSelected(element),
20971 return selection.deselect(element);
20975 return selection.select(element);
20980 selection.select(element, add);
20984 selection.deselect(element);
20997 function isShown(element) { argument
20998 return !element.hidden;
21184 if (isString(search.element)) {
21185 search.element = this._elementRegistry.get(search.element);
21188 if (search.element) {
21189 var container = this._getOverlayContainer(search.element, true);
21230 Overlays.prototype.add = function(element, type, overlay) { argument
21237 if (!element.id) {
21238 element = this._elementRegistry.get(element);
21249 if (!element) {
21258 element: element,
21288 var container = self._getOverlayContainer(overlay.element, true);
21295 delete overlay.element;
21329 var element = container.element,
21335 var x = element.x,
21336 y = element.y;
21338 if (element.waypoints) {
21339 var bbox = getBBox(element);
21346 attr$1(container.html, 'data-container-id', element.id);
21354 element = overlay.element;
21367 if (element.waypoints) {
21368 width = getBBox(element).width;
21370 width = element.width;
21380 if (element.waypoints) {
21381 height = getBBox(element).height;
21383 height = element.height;
21393 Overlays.prototype._createOverlayContainer = function(element) { argument
21400 element: element, property in AnonymousFunctionf8d14cd11cc00.container
21430 Overlays.prototype._getOverlayContainer = function(element, raw) { argument
21432 return c.element === element;
21437 return this._createOverlayContainer(element);
21447 element = overlay.element,
21463 overlayContainer = this._getOverlayContainer(element);
21473 var plane = this._canvas.findPlane(element);
21587 var element = e.element;
21588 var overlays = self.get({ element: element });
21594 var container = self._getOverlayContainer(element);
21609 var element = e.element;
21611 var container = self._getOverlayContainer(element, true);
21626 var container = self._getOverlayContainer(e.element, true);
21891 Keyboard.prototype._getAllowedModifiers = function(element) { argument
21892 var modifierContainer = closest(element, '[' + HANDLE_MODIFIER_ATTRIBUTE + ']', true);
22567 var element = this._container;
22588 var elementRect = element.getBoundingClientRect();
22671 var element = this._container;
22685 componentEvent[newEnabled ? 'bind' : 'unbind'](element, 'wheel', handleWheel, false);
23104 function getWindowForElement(element) { argument
23105 var doc = element.ownerDocument || element;
23151 this.element = manager.element;
23177 this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
23179 … this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
23186 this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
23188 …this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
23299 var target = manager.element;
23950 if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {
23951 this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
24867 function Hammer(element, options) { argument
24870 return new Manager(element, options);
24999 function Manager(element, options) { argument
25002 this.options.inputTarget = this.options.inputTarget || element;
25009 this.element = element;
25257 this.element && toggleCssProps(this, false);
25262 this.element = null;
25272 var element = manager.element;
25273 if (!element.style) {
25278 prop = prefixed(element.style, name);
25280 manager.oldCssProps[prop] = element.style[prop];
25281 element.style[prop] = value;
25283 element.style[prop] = manager.oldCssProps[prop] || '';
25554 element = gfx && elementRegistry.get(gfx);
25557 if (move && canvas.getRootElement() !== element) {
25558 return move.start(event, element, true);
25614 element = gfx && elementRegistry.get(gfx);
25616 if (element !== event.hover) {
25621 if (element) {
25622 dragging.hover({ element: element, gfx: gfx });
25624 event.hover = element;
25755 function sortTopOrMiddle(element) { argument
25756 return element.y;
25759 function sortLeftOrCenter(element) { argument
25760 return element.x;
25773 right: function(element) { argument
25774 return element.x + element.width;
25778 bottom: function(element) { argument
25779 return element.y + element.height;
25853 forEach(sortedElements, function(element) { argument
25854 var center = element[axis] + Math.round(element[dimension] / 2);
25857 centers[center].elements.push(element);
25860 elements: [ element ],
25882 sortedElements = sortBy(sortedElements, function(element) { argument
25883 return element[axis] + element[dimension];
25903 var filteredElements = filter(elements, function(element) { argument
25904 return !(element.waypoints || element.host || element.labelTarget);
25943 function findFreePosition(source, element, position, getNextPosition) { argument
25946 while ((connectedAtPosition = getConnectedAtPosition(source, position, element))) {
25947 position = getNextPosition(element, position, connectedAtPosition);
25963 return function(element, previousPosition, connectedAtPosition) { argument
25984 connectedAtPosition[ axis ] + margin - element[ dimension ] / 2,
25989 …connectedAtPosition[ axis ] + connectedAtPosition[ dimension ] + margin + element[ dimension ] / 2,
26005 function getConnectedAtPosition(source, position, element) { argument
26008 x: position.x - (element.width / 2),
26009 y: position.y - (element.height / 2),
26010 width: element.width,
26011 height: element.height
26018 if (target === element) {
26192 function getConnected(element) { argument
26193 return getTargets(element).concat(getSources(element));
26287 function getNewShapePosition$1(source, element, hints) { argument
26299 x: sourceTrbl.right + distance + element.width / 2,
26337 function isAny(element, types) { argument
26339 return is$1(element, t);
26352 function getParent(element, anyType) { argument
26358 while ((element = element.parent)) {
26359 if (isAny(element, anyType)) {
26360 return element;
26376 function getNewShapePosition(source, element) { argument
26378 if (is$1(element, 'bpmn:TextAnnotation')) {
26379 return getTextAnnotationPosition(source, element);
26382 if (isAny(element, [ 'bpmn:DataObjectReference', 'bpmn:DataStoreReference' ])) {
26383 return getDataElementPosition(source, element);
26386 if (is$1(element, 'bpmn:FlowNode')) {
26387 return getFlowNodePosition(source, element);
26395 function getFlowNodePosition(source, element) { argument
26419 x: sourceTrbl.right + horizontalDistance + element.width / 2,
26430 …return findFreePosition(source, element, position, generateGetNextPosition(nextPositionDirection));
26448 function getTextAnnotationPosition(source, element) { argument
26453 x: sourceTrbl.right + element.width / 2,
26454 y: sourceTrbl.top - 50 - element.height / 2
26464 …return findFreePosition(source, element, position, generateGetNextPosition(nextPositionDirection));
26471 function getDataElementPosition(source, element) { argument
26476 x: sourceTrbl.right - 10 + element.width / 2,
26477 y: sourceTrbl.bottom + 40 + element.width / 2
26487 …return findFreePosition(source, element, position, generateGetNextPosition(nextPositionDirection));
26691 var expandings = groupBy(elements, function(element) { argument
26692 return element.parent.id;
26699 elements = elements.filter(function(element) { argument
26700 return find(autoResize, matchPattern({ id: element.id }));
27093 forEach(elements, function(element) { argument
27095 if (is$1(element, 'bpmn:Lane') || element.labelTarget) {
27152 var element = gfx && elementRegistry.get(gfx);
27154 if (gfx && element) {
27160 dragging.hover({ element: element, gfx: gfx });
27209 hover = event.element;
27219 element: hover,
27420 var existingSelection = previousSelection.filter(function(element) { argument
27421 return elementRegistry.get(element.id);
27576 payload.hover = event.element;
28476 function bindInteractionEvents(node, eventName, element) { argument
28479 interactionEvents.triggerMouseEvent(eventName, event, element);
28484 function getBendpointsContainer(element, create) { argument
28487 gfx = query('.djs-bendpoints[data-element-id="' + cssEscape(element.id) + '"]', layer);
28491 attr(gfx, { 'data-element-id': element.id });
28496 bindInteractionEvents(gfx, 'mousedown', element);
28497 bindInteractionEvents(gfx, 'click', element);
28498 bindInteractionEvents(gfx, 'dblclick', element);
28631 updateHandles(event.element);
28635 var gfx = getBendpointsContainer(event.element);
28644 var element = event.element,
28647 if (!element.waypoints) {
28651 bendpointsGfx = addHandles(element);
28662 var element = event.element,
28663 waypoints = element.waypoints,
28668 bendpointsGfx = getBendpointsContainer(element, true);
28692 element = event.element;
28694 if (!element.waypoints) {
28698 return activateBendpointMove(originalEvent, element);
28711 var element = event.element;
28713 if (element.waypoints) {
28714 addHandles(element);
28725 var element = context.element,
28728 if (element.waypoints) {
28729 var bendpointContainer = getBendpointsContainer(element);
29759 function mid(element) { argument
29760 if (element.width) {
29762 x: round$6(element.width / 2 + element.x),
29763 y: round$6(element.height / 2 + element.y)
31009 active.provider.update(active.element, newText, active.context.text, {
31060 DirectEditing.prototype.activate = function(element) { argument
31069 return (context = p.activate(element)) ? p : null;
31082 element: element, property in AnonymousFunctionf8d14cd12e500._active
31182 var element = event.element,
31186 if (current && current.element === element) {
31187 self.open(element, true);
31235 ContextPad.prototype.getEntries = function(element) { argument
31243 var entriesOrUpdater = provider.getContextPadEntries(element);
31267 var element = this._current.element,
31286 return handler(originalEvent, element, autoActivate);
31290 return handler[action](originalEvent, element, autoActivate);
31305 ContextPad.prototype.open = function(element, force) { argument
31306 if (!force && this.isOpen(element)) {
31311 this._updateAndOpen(element);
31326 ContextPad.prototype._updateAndOpen = function(element) { argument
31328 var entries = this.getEntries(element),
31329 pad = this.getPad(element),
31363 element: element, property in AnonymousFunctionf8d14cd12f400._current
31372 ContextPad.prototype.getPad = function(element) { argument
31400 this._overlayId = overlays.add(element, 'context-pad', overlaysConfig);
31404 this._eventBus.fire('contextPad.create', { element: element, pad: pad });
31434 ContextPad.prototype.isOpen = function(element) { argument
31435 return !!this._current && (!element ? true : this._current.element === element);
31443 function addClasses$1(element, classNames) { argument
31445 var classes = classes$1(element);
31514 PreviewSupport.prototype.getGfx = function(element) { argument
31515 return this._elementRegistry.getGraphics(element);
31527 PreviewSupport.prototype.addDragger = function(element, group, gfx) { argument
31528 gfx = gfx || this.getGfx(element);
31741 elements = filter(elements, function(element) { argument
31742 var labelTarget = element.labelTarget;
31744 return !element.parent && !(isLabel$5(element) && elements.indexOf(labelTarget) !== -1);
31747 var shape = find(elements, function(element) { argument
31748 return !isConnection$b(element);
31813 function setMarker(element, marker) { argument
31817 canvas.addMarker(element, m);
31819 canvas.removeMarker(element, m);
31902 shape = find(elements, function(element) { argument
31903 return !isConnection$b(element);
31943 var shape = find(elements, function(element) { argument
31944 return !isConnection$b(element);
31960 forEach(elements, function(element) { argument
31961 if (!isNumber(element.x)) {
31962 element.x = 0;
31965 if (!isNumber(element.y)) {
31966 element.y = 0;
31973 forEach(elements, function(element) { argument
31974 if (isConnection$b(element)) {
31975 element.waypoints = map$1(element.waypoints, function(waypoint) {
31983 assign(element, {
31984 x: element.x - bbox.x - bbox.width / 2,
31985 y: element.y - bbox.y - bbox.height / 2
32036 function isConnection$b(element) { argument
32037 return !!element.waypoints;
32044 function isLabel$5(element) { argument
32045 return !!element.labelTarget;
32065 elements.forEach(function(element) { argument
32070 if (element.hidden) {
32074 if (element.waypoints) {
32077 graphicsFactory.drawConnection(getVisual(gfx), element);
32081 graphicsFactory.drawShape(getVisual(gfx), element);
32083 translate$2(gfx, element.x, element.y);
32087 previewSupport.addDragger(element, dragGroup, gfx);
32237 PopupMenu.prototype.isEmpty = function(element, providerId) { argument
32238 if (!element) {
32252 var entries = this._getEntries(element, providers),
32253 headerEntries = this._getHeaderEntries(element, providers);
32271 PopupMenu.prototype.open = function(element, id, position) { argument
32275 if (!element) {
32295 element: element,
32299 var entries = this._getEntries(element, providers),
32300 headerEntries = this._getHeaderEntries(element, providers);
32365 var element = event.delegateTarget || event.target,
32366 entryId = attr$1(element, DATA_REF);
32387 PopupMenu.prototype._getEntries = function(element, providers) { argument
32395 forEach(provider.getEntries(element), function(entry) {
32408 var entriesOrUpdater = provider.getPopupMenuEntries(element);
32422 PopupMenu.prototype._getHeaderEntries = function(element, providers) { argument
32434 forEach(provider.getHeaderEntries(element), function(entry) {
32447 var entriesOrUpdater = provider.getPopupMenuHeaderEntries(element);
32713 function setTransform(element, transform) { argument
32714 element.style['transform-origin'] = 'top left';
32717 element.style[prefix + 'transform'] = transform;
32898 element = context.element,
32904 descriptor.id = element.id;
32907 return e === element.parent;
32912 descriptor.parent = element.parent.id;
32916 if (isAttacher$1(element)) {
32919 descriptor.host = element.host.id;
32923 if (isConnection$a(element)) {
32926 descriptor.source = element.source.id;
32927 descriptor.target = element.target.id;
32929 descriptor.waypoints = copyWaypoints$1(element);
32933 if (isLabel$4(element)) {
32936 descriptor.labelTarget = element.labelTarget.id;
32940 if (isNumber(element[ property ])) {
32941 descriptor[ property ] = element[ property ];
32945 descriptor.hidden = element.hidden;
32946 descriptor.collapsed = element.collapsed;
33032 if (context && context.element && context.point) {
33033 return this._paste(elements, context.element, context.point, hints);
33052 forEach(elements, function(element) { argument
33053 if (!isNumber(element.x)) {
33054 element.x = 0;
33057 if (!isNumber(element.y)) {
33058 element.y = 0;
33065 forEach(elements, function(element) { argument
33066 if (isConnection$a(element)) {
33067 element.waypoints = map$1(element.waypoints, function(waypoint) {
33075 assign(element, {
33076 x: element.x - bbox.x - bbox.width / 2,
33077 y: element.y - bbox.y - bbox.height / 2
33117 var element;
33123 element = cache[ descriptor.id ] = self.createConnection(attrs);
33125 elements.push(element);
33133 element = cache[ descriptor.id ] = self.createLabel(attrs);
33135 elements.push(element);
33144 element = cache[ descriptor.id ] = self.createShape(attrs);
33146 elements.push(element);
33180 CopyPaste.prototype.hasRelations = function(element, elements) { argument
33185 if (isConnection$a(element)) {
33186 source = find(elements, matchPattern({ id: element.source.id }));
33187 target = find(elements, matchPattern({ id: element.target.id }));
33194 if (isLabel$4(element)) {
33195 labelTarget = find(elements, matchPattern({ id: element.labelTarget.id }));
33235 function canCopy(element, elements) { argument
33237 element: element,
33242 function addElementData(element, depth) { argument
33246 return element === elementsData.element;
33252 element: element,
33264 element: foundElementData.element,
33281 eachElement(parents, function(element, _index, depth) { argument
33284 if (isLabel$4(element)) {
33289 forEach(element.labels, function(label) {
33294 elements && elements.length && forEach(elements, function(element) { argument
33297 forEach(element.labels, function(label) {
33301 addElementData(element, depth);
33305 forEach([ element.attachers, element.incoming, element.outgoing ], addRelatedElements);
33307 addElementData(element, depth);
33309 return element.children;
33313 return elementData.element;
33322 element: elementData.element,
33335 return elementData.element;
33342 if (!self.hasRelations(elementData.element, elements)) {
33343 removeElement(elementData.element, elements);
33348 if (!canCopy(elementData.element, elements)) {
33349 removeElement(elementData.element, elements);
33366 function isAttacher$1(element) { argument
33367 return !!element.host;
33370 function isConnection$a(element) { argument
33371 return !!element.waypoints;
33374 function isLabel$4(element) { argument
33375 return !!element.labelTarget;
33378 function copyWaypoints$1(element) { argument
33379 return map$1(element.waypoints, function(waypoint) {
33395 function removeElement(element, elements) { argument
33396 var index = elements.indexOf(element);
33428 function removeProperties(element, properties) { argument
33434 if (element[property]) {
33435 delete element[property];
33447 element = context.element;
33449 var businessObject = descriptor.oldBusinessObject = getBusinessObject(element);
33451 descriptor.type = element.type;
33506 element: businessObject, property in BpmnCopyPaste.resolveReferences.references
33519 var element = reference.element,
33523 element[ property ] = businessObject;
33578 function isLabel$3(element) { argument
33579 return !!element.labelTarget;
33835 ModdleCopy.prototype._copyId = function(id, element) { argument
33842 this._moddle.ids.claim(id, element);
33860 function is(element, type) { argument
33861 return element && (typeof element.$instanceOf === 'function') && element.$instanceOf(type);
33956 function toggeling(element, target) { argument
33959 element && has(element, 'collapsed') ? element.collapsed : !isExpanded(element)
33977 element.collapsed = oldCollapsed;
34009 function replaceElement(element, target, hints) { argument
34014 oldBusinessObject = element.businessObject;
34018 if (toggeling(element, target)) {
34021 modeling.toggleCollapse(element);
34023 return element;
34046 return hasEventDefinition$1(element, target.eventDefinitionType);
34106 newElement.width = element.width;
34107 newElement.height = element.height;
34129 newElement.width = element.width;
34170 newElement.x = element.x + (element.width - newElement.width) / 2;
34184 newElement = replace.replaceElement(element, newElement, hints);
34211 function hasEventDefinition$1(element, type) { argument
34213 var bo = getBusinessObject(element);
34247 function isDifferentType(element) { argument
34252 var businessObject = getBusinessObject(element),
35105 label: function(element) { argument
35108 if (element.children && element.children.length) {
35170 ReplaceMenuProvider.prototype.getEntries = function(element) { argument
35172 var businessObject = element.businessObject;
35178 if (!rules.allowed('shape.replace', { element: element })) {
35182 var differentType = isDifferentType(element);
35185 return this._createEntries(element, DATA_OBJECT_REFERENCE);
35189 return this._createEntries(element, DATA_STORE_REFERENCE);
35197 return this._createEntries(element, entries);
35207 return this._createEntries(element, entries);
35218 var isInterruptingEqual = getBusinessObject(element).isInterrupting === isInterrupting;
35225 return this._createEntries(element, entries);
35233 return this._createEntries(element, entries);
35250 return this._createEntries(element, entries);
35271 return this._createEntries(element, entries);
35280 return this._createEntries(element, entries);
35288 return this._createEntries(element, entries);
35296 return this._createEntries(element, entries);
35304 return this._createEntries(element, entries);
35312 return this._createEntries(element, entries);
35326 return isDifferentType(element) && (!isTargetSubProcess || isTargetExpanded);
35329 return this._createEntries(element, entries);
35334 return this._createSequenceFlowEntries(element, SEQUENCE_FLOW);
35348 return this._createEntries(element, entries);
35363 ReplaceMenuProvider.prototype.getHeaderEntries = function(element) { argument
35367 if (is$1(element, 'bpmn:Activity') && !isEventSubProcess(element)) {
35368 headerEntries = headerEntries.concat(this._getLoopEntries(element));
35371 if (is$1(element, 'bpmn:DataObjectReference')) {
35372 headerEntries = headerEntries.concat(this._getDataObjectIsCollection(element));
35375 if (is$1(element, 'bpmn:Participant')) {
35376 headerEntries = headerEntries.concat(this._getParticipantMultiplicity(element));
35379 if (is$1(element, 'bpmn:SubProcess') &&
35380 !is$1(element, 'bpmn:Transaction') &&
35381 !isEventSubProcess(element)) {
35382 headerEntries.push(this._getAdHocEntry(element));
35398 ReplaceMenuProvider.prototype._createEntries = function(element, replaceOptions) { argument
35404 var entry = self._createMenuEntry(definition, element);
35420 ReplaceMenuProvider.prototype._createSequenceFlowEntries = function(element, replaceOptions) { argument
35422 var businessObject = getBusinessObject(element);
35441 menuEntries.push(self._createMenuEntry(entry, element, function() {
35442 modeling.updateProperties(element.source, { default: businessObject });
35449 menuEntries.push(self._createMenuEntry(entry, element, function() {
35452 modeling.updateProperties(element, { conditionExpression: conditionExpression });
35460 return menuEntries.push(self._createMenuEntry(entry, element, function() {
35461 modeling.updateProperties(element, { conditionExpression: undefined });
35472 return menuEntries.push(self._createMenuEntry(entry, element, function() {
35473 modeling.updateProperties(element.source, { default: undefined });
35493 ReplaceMenuProvider.prototype._createMenuEntry = function(definition, element, action) { argument
35498 return replaceElement(element, definition.target);
35503 label = label(element);
35525 ReplaceMenuProvider.prototype._getLoopEntries = function(element) { argument
35542 self._modeling.updateProperties(element, { loopCharacteristics: loopCharacteristics });
35545 var businessObject = getBusinessObject(element),
35603 ReplaceMenuProvider.prototype._getDataObjectIsCollection = function(element) { argument
35610 element,
35615 var dataObject = element.businessObject.dataObjectRef,
35637 ReplaceMenuProvider.prototype._getParticipantMultiplicity = function(element) { argument
35652 element,
35656 var participantMultiplicity = element.businessObject.participantMultiplicity;
35678 ReplaceMenuProvider.prototype._getAdHocEntry = function(element) { argument
35680 var businessObject = getBusinessObject(element);
35693 return replaceElement(element, { type: 'bpmn:SubProcess' }, {
35698 return replaceElement(element, { type: 'bpmn:AdHocSubProcess' }, {
35893 function isBBoxChild(element) { argument
35896 if (element.waypoints) {
35901 if (element.type === 'label') {
36138 ContextPadProvider.prototype.getContextPadEntries = function(element) { argument
36154 if (element.type === 'label') {
36158 var businessObject = element.businessObject;
36160 function startConnect(event, element) { argument
36161 connect.start(event, element);
36165 modeling.removeElements([ element ]);
36168 function getReplaceMenuPosition(element) { argument
36173 pad = contextPad.getPad(element).html;
36207 function appendStart(event, element) { argument
36211 source: element
36216 var append = autoPlace ? function(event, element) {
36219 autoPlace.append(element, shape);
36236 return function(event, element) { argument
36239 modeling.splitLane(element, count);
36243 contextPad.open(element, true);
36250 var childLanes = getChildLanes(element);
36258 click: function(event, element) { argument
36259 modeling.addLane(element, 'top');
36267 if (element.height >= 120) {
36280 if (element.height >= 180) {
36300 click: function(event, element) { argument
36301 modeling.addLane(element, 'bottom');
36391 if (!popupMenu.isEmpty(element, 'bpmn-replace')) {
36400 click: function(event, element) { argument
36402 var position = assign(getReplaceMenuPosition(element), {
36406 popupMenu.open(element, 'bpmn-replace', position);
36480 var deleteAllowed = rules.allowed('elements.delete', { elements: [ element ] });
36485 deleteAllowed = deleteAllowed[0] === element;
36557 forEach(elements, function(element) { argument
36558 if (element.waypoints || element.labelTarget) {
36562 elementsSize += element[dimension];
36569 return filter(elements, function(element) { argument
36570 return element[dimension] < (avgDimension + 50);
36682 forEach(sortedElements, function(element, idx) { argument
36683 var elementRange = self._findRange(element, axis, dimension),
36689 rangeGroups[rangeGroups.length - 1].elements.push(element);
36691 range = { range: elementRange, elements: [ element ] };
36737 DistributeElements$1.prototype._findRange = function(element) { argument
36738 var axis = element[this._axis],
36739 dimension = element[this._dimension];
36759 return filter(elements, function(element) { argument
36760 var cannotDistribute = isAny(element, [
36772 return !(element.labelTarget || cannotDistribute);
37096 var elements = elementRegistry.filter(function(element) { argument
37097 return element !== rootElement;
37148 aligneableElements = filter(currentSelection, function(element) { argument
37149 return !is$1(element, 'bpmn:Lane');
37190 elements = elementRegistry.filter(function(element) { argument
37191 return is$1(element.parent, 'bpmn:Collaboration');
37194 elements = elementRegistry.filter(function(element) { argument
37195 return element !== rootElement && !is$1(element.parent, 'bpmn:SubProcess');
38075 var element = context.element,
38078 if (is$1(element, 'bpmn:Lane')) {
38079 return self.createParticipantHit(element, gfx);
38082 if (is$1(element, 'bpmn:Participant')) {
38083 if (isExpanded(element)) {
38084 return self.createParticipantHit(element, gfx);
38086 return self.createDefaultHit(element, gfx);
38090 if (is$1(element, 'bpmn:SubProcess')) {
38091 if (isExpanded(element)) {
38092 return self.createSubProcessHit(element, gfx);
38094 return self.createDefaultHit(element, gfx);
38107 BpmnInteractionEvents.prototype.createDefaultHit = function(element, gfx) { argument
38110 this._interactionEvents.createDefaultHit(element, gfx);
38116 BpmnInteractionEvents.prototype.createParticipantHit = function(element, gfx) { argument
38123 width: element.width,
38124 height: element.height
38130 height: element.height
38137 BpmnInteractionEvents.prototype.createSubProcessHit = function(element, gfx) { argument
38144 width: element.width,
38145 height: element.height
38150 width: element.width,
38496 var element = event.element;
38500 if (element.parent || element === canvas.getRootElement()) {
38501 event.gfx = elementRegistry.getGraphics(element);
38509 eventBus.fire(getType(element) + '.changed', event);
38517 eventBus.fire('element.changed', { element: e });
38524 graphicsFactory.update('shape', event.element, event.gfx);
38528 graphicsFactory.update('connection', event.element, event.gfx);
38928 var shape = e.element;
38939 ResizeHandles.prototype.makeDraggable = function(element, gfx, direction) { argument
38946 resize.activate(event, element, direction);
38955 ResizeHandles.prototype._createResizer = function(element, x, y, direction) { argument
38963 classes(group).add(CLS_RESIZER + '-' + element.id);
38999 ResizeHandles.prototype.createResizer = function(element, direction) { argument
39000 var point = getReferencePoint$1(element, direction);
39002 var resizer = this._createResizer(element, point.x, point.y, direction);
39004 this.makeDraggable(element, resizer, direction);
39123 activateDirectEdit(event.element, true);
39155 element = context.shape,
39179 activateDirectEdit(element);
39187 function activateDirectEdit(element, force) { argument
39189 isAny(element, [ 'bpmn:Task', 'bpmn:TextAnnotation', 'bpmn:Group' ]) ||
39190 isCollapsedSubProcess(element)) {
39192 directEditing.activate(element);
39216 LabelEditingProvider.prototype.activate = function(element) { argument
39219 var text = getLabel(element);
39230 var bounds = this.getEditingBBox(element);
39238 isAny(element, [
39244 isCollapsedSubProcess(element)
39252 if (isLabelExternal(element)) {
39259 if (is$1(element, 'bpmn:TextAnnotation')) {
39282 LabelEditingProvider.prototype.getEditingBBox = function(element) { argument
39285 var target = element.label || element;
39314 if (is$1(element, 'bpmn:Lane') || isExpandedPool(element)) {
39337 if (isAny(element, [ 'bpmn:Task', 'bpmn:CallActivity']) ||
39338 isCollapsedPool(element) ||
39339 isCollapsedSubProcess(element)) {
39358 if (isExpandedSubProcess$1(element)) {
39400 var externalLabelMid = getExternalLabelMid(element);
39427 if (is$1(element, 'bpmn:TextAnnotation')) {
39451 element, newLabel, argument
39457 if (is$1(element, 'bpmn:TextAnnotation')) {
39459 bbox = this._canvas.getAbsoluteBBox(element);
39462 x: element.x,
39463 y: element.y,
39464 width: element.width / bbox.width * bounds.width,
39465 height: element.height / bbox.height * bounds.height
39469 if (is$1(element, 'bpmn:Group')) {
39471 var businessObject = getBusinessObject(element);
39481 getBusinessObject(element).categoryValueRef = categoryValue;
39490 this._modeling.updateLabel(element, newLabel, newBounds);
39497 function isCollapsedSubProcess(element) { argument
39498 return is$1(element, 'bpmn:SubProcess') && !isExpanded(element);
39501 function isExpandedSubProcess$1(element) { argument
39502 return is$1(element, 'bpmn:SubProcess') && isExpanded(element);
39505 function isCollapsedPool(element) { argument
39506 return is$1(element, 'bpmn:Participant') && !isExpanded(element);
39509 function isExpandedPool(element) { argument
39510 return is$1(element, 'bpmn:Participant') && isExpanded(element);
39529 var element, absoluteElementBBox, gfx;
39534 element = activeProvider.element.label || activeProvider.element;
39537 if (is$1(element, 'bpmn:TextAnnotation')) {
39538 absoluteElementBBox = canvas.getAbsoluteBBox(element);
39545 containerWidth: element.width,
39546 containerHeight: element.height,
39558 stroke: getStrokeColor(element)
39565 translate$2(gfx, element.x, element.y);
39568 if (is$1(element, 'bpmn:TextAnnotation') ||
39569 element.labelTarget) {
39570 canvas.addMarker(element, MARKER_HIDDEN);
39571 } else if (is$1(element, 'bpmn:Task') ||
39572 is$1(element, 'bpmn:CallActivity') ||
39573 is$1(element, 'bpmn:SubProcess') ||
39574 is$1(element, 'bpmn:Participant')) {
39575 canvas.addMarker(element, MARKER_LABEL_HIDDEN);
39582 if (is$1(element, 'bpmn:TextAnnotation')) {
39586 … var newElementHeight = Math.max(element.height / absoluteElementBBox.height * (height + dy), 0);
39591 containerWidth: element.width,
39609 canvas.removeMarker(activeProvider.element.label || activeProvider.element, MARKER_HIDDEN);
39610 canvas.removeMarker(element, MARKER_LABEL_HIDDEN);
39613 element = undefined;
39634 function getStrokeColor(element, defaultColor) { argument
39635 var bo = getBusinessObject(element);
39714 elements.forEach(function(element) { argument
39715 checkLabelAdjustment(element);
39720 function checkLabelAdjustment(element) { argument
39723 if (!hasExternalLabel(element)) {
39727 var optimalPosition = getOptimalPosition(element);
39734 adjustLabelPosition(element, optimalPosition);
39737 function adjustLabelPosition(element, orientation) { argument
39739 var elementMid = getMid(element),
39740 label = element.label,
39748 var elementTrbl = asTRBL(element);
39813 function getTakenHostAlignments(element) { argument
39815 var hostElement = element.host,
39816 elementMid = getMid(element),
39844 function getTakenConnectionAlignments(element) { argument
39846 var elementMid = getMid(element);
39849 element.incoming.map(function(c) {
39852 element.outgoing.map(function(c) {
39870 function getOptimalPosition(element) { argument
39872 var labelMid = getMid(element.label);
39874 var elementMid = getMid(element);
39882 var takenAlignments = getTakenConnectionAlignments(element);
39884 if (element.host) {
39885 var takenHostAlignments = getTakenHostAlignments(element);
39997 elements.map(function(element) { argument
39998 return elements.indexOf(element);
40048 function getEventDefinition$1(element) { argument
40049 var businessObject = getBusinessObject(element),
40070 function getBoundaryEvents(element) { argument
40071 return filter(element.attachers, function(attacher) {
40145 function canHaveRootElementReference(element) { argument
40146 return isAny(element, [ 'bpmn:ReceiveTask', 'bpmn:SendTask' ]) ||
40147 hasAnyEventDefinition(element, [
40233 element = context.element;
40235 if (!canHaveRootElementReference(element)) {
40239 var businessObject = getBusinessObject(element),
40284 function hasAnyEventDefinition(element, types) { argument
40290 return hasEventDefinition$2(element, type);
40488 var children = rootElement.children.filter(function(element) { argument
40489 return !is$1(element, 'bpmn:Group') &&
40490 !isLabel$6(element) &&
40491 !isConnection$9(element);
40518 event.element = rootElement;
40687 function isConnection$9(element) { argument
40688 return !!element.waypoints;
40692 return find(elements, function(element) { argument
40693 return is$1(element, 'bpmn:Participant');
40732 function usesTargetRef(element, targetRef, removedConnection) { argument
40734 var inputAssociations = element.get('dataInputAssociations');
40742 function getTargetRef(element, create) { argument
40744 var properties = element.get('properties');
40761 function cleanupTargetRef(element, connection) { argument
40763 var targetRefProp = getTargetRef(element);
40769 if (!usesTargetRef(element, targetRefProp, connection)) {
40770 remove(element.get('properties'), targetRefProp);
40885 return elementRegistry.filter(function(element) { argument
40886 return is$1(element, 'bpmn:Participant') && getBusinessObject(element).processRef;
40890 function getDataStores(element) { argument
40891 return element.children.filter(function(child) {
41059 function getAncestor(element, type) { argument
41061 while (element.parent) {
41062 if (is$1(element.parent, type)) {
41063 return element.parent;
41066 element = element.parent;
41088 eachElement(siblings, function(element) { argument
41090 if (element.y > shape.y) {
41091 bottomAffected.push(element);
41093 topAffected.push(element);
41096 return element.children;
41237 function getEventDefinition(element) { argument
41238 var businessObject = getBusinessObject(element),
41372 var connection = find(newParent.children, function(element) { argument
41373 var canInsert = bpmnRules.canInsert(shapes, element);
41375 return canInsert && getApproxIntersection(element.waypoints, newShapeMid);
41812 var element = e.element;
41814 if (element.waypoints) {
41815 fixDockings(element);
42580 element = context.element,
42584 modeling.updateLabel(element, properties[NAME_PROPERTY]);
42588 && is$1(element, 'bpmn:TextAnnotation')) {
42592 x: element.x,
42593 y: element.y,
42594 width: element.width,
42595 height: element.height
42600 modeling.updateLabel(element, properties.text, newBounds);
42613 var element = context.shape || context.connection,
42614 businessObject = element.businessObject;
42616 if (isLabel$6(element) || !isLabelExternal(element)) {
42621 if (!getLabel(element)) {
42625 var labelCenter = getExternalLabelMid(element);
42630 getLabel(element)
42633 modeling.createLabel(element, labelCenter, {
42657 element = context.shape,
42662 if (!element.labelTarget) {
42667 if (!is$1(element.labelTarget || element, 'bpmn:BaseElement')) {
42671 businessObject = element.businessObject,
42682 x: element.x,
42683 y: element.y,
42684 width: element.width,
42685 height: element.height
43059 elements.forEach(function(element) { argument
43060 if (element === parent) {
43064 element.incoming.forEach(function(connection) {
43070 element.outgoing.forEach(function(connection) {
43257 element = context.element,
43258 businessObject = element.businessObject,
43264 element.outgoing,
43265 matchPattern({ id: element.businessObject.default.id })
43275 modeling.updateProperties(element.source, { default: undefined });
43805 function hasChildLanes(element) { argument
43806 return !!getChildLanes(element).length;
44440 return every(elements, function(element) { argument
44441 if (isConnection$8(element)) {
44442 return canConnect(element.source, element.target, element);
44445 if (element.host) {
44446 return canAttach(element, element.host, null, position);
44449 return canCreate(element, target, null);
44485 var element = context.element,
44488 return canCopy(elements, element);
44528 function canStartConnection(element) { argument
44529 if (nonExistingOrLabel(element)) {
44533 return isAny(element, [
44543 function nonExistingOrLabel(element) { argument
44544 return !element || isLabel$6(element);
44551 function getOrganizationalParent(element) { argument
44554 if (is$1(element, 'bpmn:Process')) {
44555 return getBusinessObject(element);
44558 if (is$1(element, 'bpmn:Participant')) {
44560 getBusinessObject(element).processRef ||
44561 getBusinessObject(element)
44564 } while ((element = element.parent));
44568 function isTextAnnotation(element) { argument
44569 return is$1(element, 'bpmn:TextAnnotation');
44572 function isGroup(element) { argument
44573 return is$1(element, 'bpmn:Group') && !element.labelTarget;
44576 function isCompensationBoundary(element) { argument
44577 return is$1(element, 'bpmn:BoundaryEvent') &&
44578 hasEventDefinition(element, 'bpmn:CompensateEventDefinition');
44592 function isMessageFlowSource(element) { argument
44594 is$1(element, 'bpmn:InteractionNode') &&
44595 !is$1(element, 'bpmn:BoundaryEvent') && (
44596 !is$1(element, 'bpmn:Event') || (
44597 is$1(element, 'bpmn:ThrowEvent') &&
44598 hasEventDefinitionOrNone(element, 'bpmn:MessageEventDefinition')
44604 function isMessageFlowTarget(element) { argument
44606 is$1(element, 'bpmn:InteractionNode') &&
44607 !isForCompensation(element) && (
44608 !is$1(element, 'bpmn:Event') || (
44609 is$1(element, 'bpmn:CatchEvent') &&
44610 hasEventDefinitionOrNone(element, 'bpmn:MessageEventDefinition')
44613 is$1(element, 'bpmn:BoundaryEvent') &&
44614 !hasEventDefinition(element, 'bpmn:MessageEventDefinition')
44619 function getScopeParent(element) { argument
44621 var parent = element;
44644 function hasEventDefinition(element, eventDefinition) { argument
44645 var bo = getBusinessObject(element);
44652 function hasEventDefinitionOrNone(element, eventDefinition) { argument
44653 var bo = getBusinessObject(element);
44660 function isSequenceFlowSource(element) { argument
44662 is$1(element, 'bpmn:FlowNode') &&
44663 !is$1(element, 'bpmn:EndEvent') &&
44664 !isEventSubProcess(element) &&
44665 !(is$1(element, 'bpmn:IntermediateThrowEvent') &&
44666 hasEventDefinition(element, 'bpmn:LinkEventDefinition')
44668 !isCompensationBoundary(element) &&
44669 !isForCompensation(element)
44673 function isSequenceFlowTarget(element) { argument
44675 is$1(element, 'bpmn:FlowNode') &&
44676 !is$1(element, 'bpmn:StartEvent') &&
44677 !is$1(element, 'bpmn:BoundaryEvent') &&
44678 !isEventSubProcess(element) &&
44679 !(is$1(element, 'bpmn:IntermediateCatchEvent') &&
44680 hasEventDefinition(element, 'bpmn:LinkEventDefinition')
44682 !isForCompensation(element)
44686 function isEventBasedTarget(element) { argument
44688 is$1(element, 'bpmn:ReceiveTask') || (
44689 is$1(element, 'bpmn:IntermediateCatchEvent') && (
44690 hasEventDefinition(element, 'bpmn:MessageEventDefinition') ||
44691 hasEventDefinition(element, 'bpmn:TimerEventDefinition') ||
44692 hasEventDefinition(element, 'bpmn:ConditionalEventDefinition') ||
44693 hasEventDefinition(element, 'bpmn:SignalEventDefinition')
44699 function isConnection$8(element) { argument
44700 return element.waypoints;
44703 function getParents(element) { argument
44707 while (element) {
44708 element = element.parent;
44710 if (element) {
44711 parents.push(element);
44718 function isParent(possibleParent, element) { argument
44719 var allParents = getParents(element);
44768 function canDrop(element, target, position) { argument
44771 if (isLabel$6(element) || isGroup(element)) {
44783 if (is$1(element, 'bpmn:Participant')) {
44788 if (isAny(element, [ 'bpmn:DataInput', 'bpmn:DataOutput' ])) {
44790 if (element.parent) {
44791 return target === element.parent;
44796 if (is$1(element, 'bpmn:Lane')) {
44801 if (is$1(element, 'bpmn:BoundaryEvent') && !isDroppableBoundaryEvent(element)) {
44807 if (is$1(element, 'bpmn:FlowElement') && !is$1(element, 'bpmn:DataStoreReference')) {
44816 if (is$1(element, 'bpmn:DataStoreReference') && is$1(target, 'bpmn:Collaboration')) {
44826 if (isAny(element, [ 'bpmn:Artifact', 'bpmn:DataAssociation', 'bpmn:DataStoreReference' ])) {
44835 if (is$1(element, 'bpmn:MessageFlow')) {
44837 || element.source.parent == target
44838 || element.target.parent == target;
44850 function isBoundaryEvent(element) { argument
44851 return !isLabel$6(element) && is$1(element, 'bpmn:BoundaryEvent');
44854 function isLane(element) { argument
44855 return is$1(element, 'bpmn:Lane');
44862 function isBoundaryCandidate(element) { argument
44863 if (isBoundaryEvent(element)) {
44867 if (is$1(element, 'bpmn:IntermediateThrowEvent') && hasNoEventDefinition(element)) {
44872 is$1(element, 'bpmn:IntermediateCatchEvent') &&
44873 hasCommonBoundaryIntermediateEventDefinition(element)
44877 function hasNoEventDefinition(element) { argument
44878 var bo = getBusinessObject(element);
44883 function hasCommonBoundaryIntermediateEventDefinition(element) { argument
44884 return hasOneOfEventDefinitions(element, [
44892 function hasOneOfEventDefinitions(element, eventDefinitions) { argument
44894 return hasEventDefinition(element, definition);
44898 function isReceiveTaskAfterEventBasedGateway(element) { argument
44900 is$1(element, 'bpmn:ReceiveTask') &&
44901 find(element.incoming, function(incoming) {
44919 var element = elements[0];
44922 if (isLabel$6(element)) {
44927 if (!isBoundaryCandidate(element)) {
44984 forEach(elements, function(element) { argument
44988 if (is$1(element, 'bpmn:StartEvent') &&
44989 element.type !== 'label' &&
44990 canDrop(element, target)) {
44994 if (!isInterrupting(element)) {
44996 oldElementId: element.id,
45003 if (hasErrorEventDefinition(element) ||
45004 hasEscalationEventDefinition(element) ||
45005 hasCompensateEventDefinition(element)) {
45007 oldElementId: element.id,
45014 if (hasOneOfEventDefinitions(element,
45023 oldElementId: element.id,
45031 if (hasEventDefinition(element, 'bpmn:CancelEventDefinition') &&
45032 element.type !== 'label') {
45034 if (is$1(element, 'bpmn:EndEvent') && canDrop(element, target)) {
45036 oldElementId: element.id,
45041 if (is$1(element, 'bpmn:BoundaryEvent') && canAttach(element, target, null, position)) {
45043 oldElementId: element.id,
45066 return elements.every(function(element) { argument
45067 return canDrop(element, target);
45246 function includes$5(elements, element) { argument
45247 return (elements && element) && elements.indexOf(element) !== -1;
45250 function canCopy(elements, element) { argument
45251 if (isLabel$6(element)) {
45255 if (is$1(element, 'bpmn:Lane') && !includes$5(elements, element.parent)) {
45275 function getRootElement(element) { argument
45276 return getParent(element, 'bpmn:Process') || getParent(element, 'bpmn:Collaboration');
45302 elements = filter(elements, function(element) { argument
45303 return element !== root && !element.labelTarget;
45360 element = context.shape || context.connection,
45363 var ordering = self.getOrdering(element, parent);
45378 element = context.shape || context.connection,
45379 parent = context.newParent || element.parent;
45381 var ordering = self.getOrdering(element, parent);
45406 OrderingProvider.prototype.getOrdering = function(element, newParent) { argument
45479 function computeOrder(element) { argument
45480 if (element.labelTarget) {
45485 return isAny(element, [ o.type ]);
45491 function getOrder(element) { argument
45493 var order = element.order;
45496 element.order = order = computeOrder(element);
45500 throw new Error('no order for <' + element.id + '>');
45506 function findActualParent(element, newParent, containers) { argument
45520 … throw new Error('no parent for <' + element.id + '> in <' + (newParent && newParent.id) + '>');
45526 this.getOrdering = function(element, newParent) { argument
45529 if (element.labelTarget) {
45536 var elementOrder = getOrder(element);
45539 newParent = findActualParent(element, newParent, elementOrder.containers);
45542 var currentIndex = newParent.children.indexOf(element);
45549 if (!element.labelTarget && child.labelTarget) {
46534 forEach(shapes, function(element) { argument
46536 forEach(element.labels, function(label) {
46542 if (element.labelTarget) {
46543 labels.push(element);
46564 forEach(enclosedElements, function(element) { argument
46565 forEach(element.labels, function(label) {
46583 element = context.connection || context.shape;
46585 saveClear(element.labels, function(label) {
46643 return filter(elements, function(element) { argument
46647 return elements.indexOf(element.labelTarget) === -1;
46949 return filter(elements, function(element) { argument
46950 while (element) {
46953 if (element.host && ids[element.host.id]) {
46957 element = element.parent;
47472 forEach(elements, function(element) { argument
47473 if (!element.parent || isConnection$7(element)) {
47477 var shapeStart = element[ axis ],
47478 shapeEnd = shapeStart + element[ AXIS_TO_DIMENSION[ axis ] ];
47482 return movingShapes.push(element);
47488 rules.allowed('shape.resize', { shape: element })
47491 return resizingShapes.push(element);
47674 function isConnection$7(element) { argument
47675 return !!element.waypoints;
47678 function isLabel$2(element) { argument
47679 return !!element.labelTarget;
47703 forEach(collection, function(element) { argument
47704 previewSupport.addDragger(element, dragGroup);
47706 canvas.addMarker(element, MARKER_DRAGGING$1);
47792 … var movingConnections = context.movingConnections = elementRegistry.filter(function(element) { argument
47797 if (element === connection) {
47807 if (element === connection) {
47817 if (element === connection) {
47827 if (element === connection) {
47833 return isConnection$6(element)
47858 element: frame,
47885 var element = frame.element,
47891 attr(element, {
47897 attr(element, {
47904 attr(element, {
47910 attr(element, {
47969 function isConnection$6(element) { argument
47970 return element.waypoints;
47993 BpmnFactory.prototype._needsId = function(element) { argument
47994 return isAny(element, [
48014 BpmnFactory.prototype._ensureId = function(element) { argument
48020 if (is$1(element, 'bpmn:Activity')) {
48022 } else if (is$1(element, 'bpmn:Event')) {
48024 } else if (is$1(element, 'bpmn:Gateway')) {
48026 } else if (isAny(element, [ 'bpmn:SequenceFlow', 'bpmn:MessageFlow' ])) {
48029 prefix = (element.$type || '').replace(/^[^:]*:/g, '');
48034 if (!element.id && this._needsId(element)) {
48035 element.id = this._model.ids.nextPrefixed(prefix, element);
48041 var element = this._model.create(type, attrs || {});
48043 this._ensureId(element);
48045 return element;
48151 var element = context.shape || context.connection,
48156 self.updateParent(element, oldParent);
48235 if (event.element.type === 'label') {
48236 updateBounds({ context: { shape: event.element } });
48360 BpmnUpdater.prototype.updateParent = function(element, oldParent) { argument
48363 if (element instanceof Label) {
48368 if (is$1(element, 'bpmn:DataStoreReference') &&
48369 element.parent &&
48370 is$1(element.parent, 'bpmn:Collaboration')) {
48374 var parentShape = element.parent;
48376 var businessObject = element.businessObject,
48380 if (is$1(element, 'bpmn:FlowNode')) {
48384 if (is$1(element, 'bpmn:DataOutputAssociation')) {
48385 if (element.source) {
48386 parentBusinessObject = element.source.businessObject;
48392 if (is$1(element, 'bpmn:DataInputAssociation')) {
48393 if (element.target) {
48394 parentBusinessObject = element.target.businessObject;
48402 if (is$1(element, 'bpmn:DataObjectReference') && businessObject.dataObjectRef) {
48486 function getDefinitions(element) { argument
48487 while (element && !is$1(element, 'bpmn:Definitions')) {
48488 element = element.$parent;
48491 return element;
48640 element: businessObject.id,
48773 element = context.shape || context.connection;
48775 if (is$1(element, 'bpmn:BaseElement')) {
48993 function applyAttributes(element, attrs, attributeNames) { argument
48997 applyAttribute(element, attrs, property);
49010 function applyAttribute(element, attrs, attributeName) { argument
49011 element[attributeName] = attrs[attributeName];
49035 forEach(elements, function(element) { argument
49042 delta.x = alignment.left - element.x;
49045 delta.x = (alignment.right - element.width) - element.x;
49048 delta.x = (alignment.center - Math.round(element.width / 2)) - element.x;
49051 delta.y = alignment.top - element.y;
49054 delta.y = (alignment.bottom - element.height) - element.y;
49057 delta.y = (alignment.middle - Math.round(element.height / 2)) - element.y;
49060 modeling.moveElements([ element ], delta, element.parent);
49217 forEach(elements, function(element) { argument
49218 if (!isNumber(element.x)) {
49219 element.x = 0;
49222 if (!isNumber(element.y)) {
49223 element.y = 0;
49230 forEach(elements, function(element) { argument
49231 if (isConnection$5(element)) {
49232 element.waypoints = map$1(element.waypoints, function(waypoint) {
49240 assign(element, {
49241 x: round$3(element.x - bbox.x - bbox.width / 2 + position.x),
49242 y: round$3(element.y - bbox.y - bbox.height / 2 + position.y)
49250 forEach(elements, function(element) { argument
49251 if (isConnection$5(element)) {
49252 cache[ element.id ] = isNumber(parentIndex) ?
49254 cache[ element.source.id ],
49255 cache[ element.target.id ],
49257 element,
49258 element.parent || parent,
49262 cache[ element.source.id ],
49263 cache[ element.target.id ],
49264 element,
49265 element.parent || parent,
49274 if (parents.indexOf(element) === -1) {
49278 cache[ element.id ] = isNumber(parentIndex) ?
49280 element,
49281 pick(element, [ 'x', 'y', 'width', 'height' ]),
49282 element.parent || parent,
49287 element,
49288 pick(element, [ 'x', 'y', 'width', 'height' ]),
49289 element.parent || parent,
49299 function isConnection$5(element) { argument
49300 return !!element.waypoints;
49509 forEach(elements, function(element) { argument
49513 if (!elementRegistry.get(element.id)) {
49517 if (element.waypoints) {
49518 modeling.removeConnection(element);
49520 modeling.removeShape(element);
49609 function isConnection$4(element) { argument
49610 return element.waypoints;
49634 function updateRange(group, element) { argument
49635 group.range.min = Math.min(element[axis], group.range.min);
49636 group.range.max = Math.max(element[axis] + element[dimension], group.range.max);
49639 function center(element) { argument
49640 return element[axis] + element[dimension] / 2;
49651 function centerElement(refCenter, element) { argument
49654 delta[axis] = refCenter - center(element);
49660 modeling.moveElements([ element ], delta, element.parent);
49699 forEach(sortedElements, function(element) { argument
49701 centerElement(refCenter, element);
49705 min: element[axis],
49706 max: element[axis] + element[dimension]
49713 updateRange(group, element);
49741 forEach(group.elements, function(element, idx) { argument
49743 delta[axis] = (prevGroup.range.max - element[axis]) + margin;
49745 if (group.range.min !== element[axis]) {
49746 delta[axis] += element[axis] - group.range.min;
49750 modeling.moveElements([ element ], delta, element.parent);
49753 group.range.max = Math.max(element[axis] + element[dimension], idx ? group.range.max : 0);
49881 MoveClosure.prototype.add = function(element, isTopLevel) { argument
49882 return this.addAll([ element ], isTopLevel);
50505 forEach(shapes, function(element) { argument
50506 self._modeling.moveShape(element, delta, null, {
50715 forEach(elements, function(element) { argument
50716 result[element.id] = element.hidden;
50718 if (element.children) {
50719 result = assign({}, result, getElementsVisibilityRecursive(element.children));
50729 forEach(elements, function(element) { argument
50730 element.hidden = newHidden;
50732 result = result.concat(element);
50734 if (element.children) {
50735 result = result.concat(setHiddenRecursive(element.children, element.collapsed || newHidden));
50744 forEach(elements, function(element) { argument
50745 element.hidden = lastState[element.id];
50747 result = result.concat(element);
50749 if (element.children) {
50750 result = result.concat(restoreVisibilityRecursive(element.children, lastState));
51346 var element = context.element,
51354 var changed = context.changed || this.getVisualReferences(moddleElement).concat(element);
51410 return elementRegistry.filter(function(element) { argument
51412 is$1(element, 'bpmn:DataObjectReference') &&
51413 getBusinessObject(element).dataObjectRef === dataObject
51470 var element = context.element,
51471 changed = [ element ],
51474 if (!element) {
51481 var businessObject = element.businessObject,
51488 elementRegistry.updateId(element, properties[ID]);
51518 var element = context.element,
51519 label = element.label;
51543 var element = context.element,
51546 businessObject = element.businessObject,
51556 elementRegistry.updateId(element, oldProperties[ID]);
51765 eachElement(lanesRoot, function(element) { argument
51766 allAffected.push(element);
51769 if (element.label) {
51770 allAffected.push(element.label);
51773 if (element === shape) {
51777 return filter(element.children, function(c) {
51957 eachElement(lanesRoot, function(element) { argument
51958 allAffected.push(element);
51960 if (is$1(element, 'bpmn:Lane') || is$1(element, 'bpmn:Participant')) {
51961 allLanes.push(element);
51964 return element.children;
52027 function isInLaneShape(element, laneShape) { argument
52032 x: element.x + element.width / 2,
52033 y: element.y + element.height / 2
52187 element = context.element,
52191 ids.claim(id, element);
52203 element = context.element,
52209 ids.claim(id, element);
52264 forEach(elements, function(element) { argument
52265 var assignedDi = isConnection$3(element) ? pick(di, [ 'border-color' ]) : di;
52271 element: element,
52311 function isConnection$3(element) { argument
52312 return !!element.waypoints;
52348 function setText(element, text) { argument
52351 var label = element.label || element;
52353 var labelTarget = element.labelTarget || element;
52361 var element = ctx.element,
52362 businessObject = element.businessObject,
52365 if (!isLabel$6(element)
52366 && isLabelExternal(element)
52367 && !hasExternalLabel(element)
52373 var labelCenter = getExternalLabelMid(element);
52380 modeling.createLabel(element, labelCenter, {
52388 ctx.oldLabel = getLabel(ctx.element);
52389 return setText(ctx.element, ctx.newLabel);
52393 return setText(ctx.element, ctx.oldLabel);
52397 var element = ctx.element,
52398 label = element.label || element,
52496 Modeling.prototype.updateLabel = function(element, newLabel, newBounds, hints) { argument
52498 element: element,
52522 Modeling.prototype.updateModdleProperties = function(element, moddleElement, properties) { argument
52524 element: element,
52530 Modeling.prototype.updateProperties = function(element, properties) { argument
52532 element: element,
52613 element: moddleElement,
52622 element: moddleElement
53577 function isExpandedSubProcess(element) { argument
53578 return is$1(element, 'bpmn:SubProcess') && isExpanded(element);
53859 CroppingConnectionDocking.prototype._getGfx = function(element) { argument
53860 return this._elementRegistry.getGraphics(element);
53896 function mid(element) { argument
53898 x: element.x + round(element.width / 2),
53899 y: element.y + round(element.height / 2)
54059 return start(originalEvent, event.element);
54070 function start(event, element, activate, context) { argument
54077 if (element.waypoints || !element.parent) {
54081 var referencePoint = mid(element);
54087 shape: element,
54122 return filter(elements, function(element) { argument
54123 while ((element = element.parent)) {
54126 if (ids[element.id]) {
54176 function setMarker(element, marker) { argument
54181 canvas.addMarker(element, m);
54183 canvas.removeMarker(element, m);
54195 function makeDraggable(context, element, addMarker) { argument
54197 previewSupport.addDragger(element, context.dragGroup);
54200 canvas.addMarker(element, MARKER_DRAGGING);
54204 context.allDraggedElements.push(element);
54206 context.allDraggedElements = [ element ];
54337 var filteredElements = filter(elements, function(element) { argument
54339 if (!isConnection$2(element)) {
54344 find(elements, matchPattern({ id: element.source.id })) &&
54345 find(elements, matchPattern({ id: element.target.id }))
54360 function isConnection$2(element) { argument
54361 return element.waypoints;
54798 function addClasses(element, classNames) { argument
54800 var classes = classes$1(element);
54910 var elements = elementRegistry.filter(function(element) { argument
54911 return element;
55426 PaletteProvider.prototype.getPaletteEntries = function(element) { argument
55633 var element = elementRegistry.get(id);
55635 assign(newElement, { x: element.x, y: element.y });
55640 canvas.addShape(tempShape, element.parent);
55643 var gfx = query('[data-element-id="' + cssEscape(element.id) + '"]', context.dragGroup);
55890 function getDimensionForAxis(axis, element) { argument
55891 return axis === 'x' ? element.width : element.height;
56257 function isConnection$1(element) { argument
56258 return !!element.waypoints;
56261 function isHidden$1(element) { argument
56262 return !!element.hidden;
56265 function isLabel$1(element) { argument
56266 return !!element.labelTarget;
56442 function isContainer(element) { argument
56443 if (is$1(element, 'bpmn:SubProcess') && isExpanded(element)) {
56447 return is$1(element, 'bpmn:Participant');
56620 function isAttached(element, host) { argument
56621 return element.host === host;
56624 function isConnection(element) { argument
56625 return !!element.waypoints;
56628 function isHidden(element) { argument
56629 return !!element.hidden;
56632 function isLabel(element) { argument
56633 return !!element.labelTarget;
56968 var id = result.element.id;
56971 element: result.element, property in self._results
57176 var element = this._results[id].element;
57180 this._resetOverlay(element);
57182 this._canvas.scrollToElement(element, { top: 400 });
57184 this._selection.select(element);
57186 this._eventBus.fire('searchPad.preselected', element);
57197 var element = this._results[id].element;
57203 this._canvas.scrollToElement(element, { top: 400 });
57205 this._selection.select(element);
57207 this._eventBus.fire('searchPad.selected', element);
57217 SearchPad.prototype._resetOverlay = function(element) { argument
57222 if (element) {
57223 var box = getBBox(element);
57225 this._overlayId = this._overlays.add(element, overlay);
57371 var elements = this._elementRegistry.filter(function(element) { argument
57372 if (element.labelTarget) {
57379 elements = filter(elements, function(element) { argument
57380 return element !== rootElement;
57383 elements = map$1(elements, function(element) { argument
57385 primaryTokens: matchAndSplit(getLabel(element), pattern),
57386 secondaryTokens: matchAndSplit(element.id, pattern),
57387 element: element
57392 elements = filter(elements, function(element) { argument
57393 return hasMatched(element.primaryTokens) || hasMatched(element.secondaryTokens);
57396 elements = sortBy(elements, function(element) { argument
57397 return getLabel(element.element) + element.element.id;