forEach(elements, function(element) {
var delta, labelTarget;
// set label's relative position to their label target
if (element.labelTarget) {
labelTarget = find(elements, matchPattern({ id: element.labelTarget }));
// just grab the delta from the first waypoint
if (labelTarget.waypoints) {
delta = posDelta(element, labelTarget.waypoints[0]);
} else {
delta = posDelta(element, labelTarget);
}
} else
if (element.priority === 3) {
// connections have priority 3
delta = [];
forEach(element.waypoints, function(waypoint) {
var waypointDelta = posDelta(waypoint, bbox);
delta.push(waypointDelta);
});
} else {
delta = posDelta(element, bbox);
}
element.delta = delta;
});
function hasEventDefinition(element, eventDefinition) {
var bo = getBusinessObject(element);
return !!find(bo.eventDefinitions || [], function(definition) {
return is(definition, eventDefinition);
});
}
function isReceiveTaskAfterEventBasedGateway(element) {
return (
is(element, 'bpmn:ReceiveTask') &&
find(element.incoming, function(incoming) {
return is(incoming.source, 'bpmn:EventBasedGateway');
})
);
}
/**
* Find BPMNDiagram in definitions by ID
*
* @param {ModdleElement<Definitions>} definitions
* @param {String} diagramId
*
* @return {ModdleElement<BPMNDiagram>|null}
*/
function findBPMNDiagram(definitions, diagramId) {
if (!diagramId) {
return null;
}
return find(definitions.diagrams, function(element) {
return element.id === diagramId;
}) || null;
}
function getConnection(source, target, connectionOrType) {
return find(source.outgoing, function(c) {
return c.target === target && (
typeof connectionOrType === 'string' ?
is(c, connectionOrType) :
c === connectionOrType
);
});
}
Overlays.prototype._getOverlayContainer = function(element, raw) {
var container = find(this._overlayContainers, function(c) {
return c.element === element;
});
if (!container && !raw) {
return this._createOverlayContainer(element);
}
return container;
};
CopyPaste.prototype.hasRelations = function(elements, element) {
var source, target, labelTarget;
if (element.waypoints) {
source = find(elements, matchPattern({ id: element.source.id }));
target = find(elements, matchPattern({ id: element.target.id }));
if (!source || !target) {
return false;
}
}
if (element.labelTarget) {
labelTarget = find(elements, matchPattern({ id: element.labelTarget.id }));
if (!labelTarget) {
return false;
}
}
return true;
};
export function getConnectedAtPosition(source, position, element) {
var bounds = {
x: position.x - (element.width / 2),
y: position.y - (element.height / 2),
width: element.width,
height: element.height
};
var closure = getAutoPlaceClosure(source, element);
return find(closure, function(target) {
if (target === element) {
return false;
}
var orientation = getOrientation(target, bounds, PLACEMENT_DETECTION_PAD);
return orientation === 'intersect';
});
}
ElementHandler.prototype.getPropertyForNode = function(node) {
var name = node.name;
var nameNs = parseNameNs(name);
var type = this.type,
model = this.model,
descriptor = getModdleDescriptor(type);
var propertyName = nameNs.name,
property = descriptor.propertiesByName[propertyName],
elementTypeName,
elementType;
// search for properties by name first
if (property) {
if (serializeAsType(property)) {
elementTypeName = node.attributes[XSI_TYPE];
// xsi type is optional, if it does not exists the
// default type is assumed
if (elementTypeName) {
// take possible type prefixes from XML
// into account, i.e.: xsi:type="t{ActualType}"
elementTypeName = normalizeXsiTypeName(elementTypeName, model);
elementType = model.getType(elementTypeName);
return assign({}, property, {
effectiveType: getModdleDescriptor(elementType).name
});
}
}
// search for properties by name first
return property;
}
var pkg = model.getPackage(nameNs.prefix);
if (pkg) {
elementTypeName = aliasToName(nameNs, pkg);
elementType = model.getType(elementTypeName);
// search for collection members later
property = find(descriptor.properties, function(p) {
return !p.isVirtual && !p.isReference && !p.isAttribute && elementType.hasType(p.type);
});
if (property) {
return assign({}, property, {
effectiveType: getModdleDescriptor(elementType).name
});
}
} else {
// parse unknown element (maybe extension)
property = find(descriptor.properties, function(p) {
return !p.isReference && !p.isAttribute && p.type === 'Element';
});
if (property) {
return property;
}
}
throw error('unrecognized element <' + nameNs.name + '>');
};
/**
* Find a suitable display candidate for definitions where the DI does not
* correctly specify one.
*/
function findDisplayCandidate(definitions) {
return find(definitions.rootElements, function(e) {
return is(e, 'bpmn:Process') || is(e, 'bpmn:Collaboration');
});
}