import { is, isAny } from '../utils/modelUtil';
|
import { findFreePosition, generateGetNextPosition, getConnectedDistance } from '../autoPlace/YmAutoPlaceUtil';
|
import { isObject } from 'min-dash';
|
import { bpmnStart } from '../config/variableName';
|
import { DEFAULT_CONNECT } from '../config/constants';
|
var HIGH_PRIORITY = 2000;
|
function distance(a: any, b: any) {
|
return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2));
|
}
|
/**
|
* Convert the given bounds to a { top, left, bottom, right } descriptor.
|
*
|
* @param {Point|Rect} bounds
|
*
|
* @return {RectTRBL}
|
*/
|
export function asTRBL(bounds: any) {
|
return {
|
top: bounds.y,
|
right: bounds.x + (bounds.width || 0),
|
bottom: bounds.y + (bounds.height || 0),
|
left: bounds.x,
|
};
|
}
|
export function getConnectionMid(connection: any) {
|
var waypoints = connection.waypoints;
|
var parts = waypoints.reduce(function (parts: any, point: any, index: any) {
|
var lastPoint = waypoints[index - 1];
|
if (lastPoint) {
|
var lastPart = parts[parts.length - 1];
|
var startLength = (lastPart && lastPart.endLength) || 0;
|
var length = distance(lastPoint, point);
|
parts.push({
|
start: lastPoint,
|
end: point,
|
startLength: startLength,
|
endLength: startLength + length,
|
length: length,
|
});
|
}
|
return parts;
|
}, []);
|
var totalLength = parts.reduce(function (length: any, part: any) {
|
return length + part.length;
|
}, 0);
|
// find which segement contains middle point
|
var midLength = totalLength / 2;
|
var i = 0;
|
var midSegment = parts[i];
|
while (midSegment.endLength < midLength) {
|
midSegment = parts[++i];
|
}
|
// calculate relative position on mid segment
|
var segmentProgress = (midLength - midSegment.startLength) / midSegment.length;
|
var midPoint = {
|
x: midSegment.start.x + (midSegment.end.x - midSegment.start.x) * segmentProgress,
|
y: midSegment.start.y + (midSegment.end.y - midSegment.start.y) * segmentProgress,
|
};
|
|
return midPoint;
|
}
|
export function roundPoint(point: any) {
|
return {
|
x: Math.round(point.x),
|
y: Math.round(point.y),
|
};
|
}
|
export function getBoundsMid(bounds: any) {
|
return roundPoint({
|
x: bounds.x + (bounds.width || 0) / 2,
|
y: bounds.y + (bounds.height || 0) / 2,
|
});
|
}
|
export function getMid(element: any) {
|
if (!!element.waypoints) return getConnectionMid(element);
|
return getBoundsMid(element);
|
}
|
export function getOrientation(rect: any, reference: any, padding: any) {
|
padding = padding || 0;
|
if (!isObject(padding)) padding = { x: padding, y: padding };
|
|
var rectOrientation = asTRBL(rect),
|
referenceOrientation = asTRBL(reference);
|
var top = rectOrientation.bottom + padding.y <= referenceOrientation.top,
|
right = rectOrientation.left - padding.x >= referenceOrientation.right,
|
bottom = rectOrientation.top - padding.y >= referenceOrientation.bottom,
|
left = rectOrientation.right + padding.x <= referenceOrientation.left;
|
var vertical = top ? 'top' : bottom ? 'bottom' : null,
|
horizontal = left ? 'left' : right ? 'right' : null;
|
if (horizontal && vertical) return vertical + '-' + horizontal;
|
else return horizontal || vertical || 'intersect';
|
}
|
|
function getVerticalDistance(orientation: any, minDistance: any) {
|
if (orientation.indexOf('top') != -1) return -1 * minDistance;
|
else if (orientation.indexOf('bottom') != -1) return minDistance;
|
else return 0;
|
}
|
/**
|
* horizontalDistance 控制距离 计算默认取50 如果有连接过 获取之前的连接距离
|
* */
|
export function getFlowNodePosition(source: any, element: any, jnpfData: any) {
|
var sourceTrbl = asTRBL(source);
|
var sourceMid = getMid(source);
|
let layout = jnpfData.data['layout']; // horizontal: 横向， vertical：纵向
|
var horizontalDistance =
|
layout?.value === 'horizontal'
|
? getConnectedDistance(source, {
|
filter: function (connection: any) {
|
return is(connection, 'bpmn:SequenceFlow');
|
},
|
})
|
: 120;
|
var margin = 30,
|
minDistance = 50,
|
orientation = 'left';
|
if (is(source, 'bpmn:BoundaryEvent')) {
|
orientation = getOrientation(source, source.host, -25);
|
if (orientation.indexOf('top') !== -1) margin *= -1;
|
}
|
var position: any = {};
|
let nextPositionDirection: any = {};
|
// 获取排序 横向还是竖向 横向
|
if (layout?.value === 'horizontal') {
|
position = {
|
x: sourceTrbl.right + DEFAULT_CONNECT + element.width / 2,
|
y: sourceMid.y + getVerticalDistance(orientation, minDistance),
|
};
|
nextPositionDirection = {
|
y: {
|
margin: margin,
|
minDistance: minDistance,
|
},
|
};
|
} else {
|
position = {
|
x: sourceTrbl.right + getVerticalDistance(orientation, minDistance),
|
y: sourceMid.y + (element.height + source.height) / 2 + horizontalDistance,
|
};
|
nextPositionDirection = {
|
x: {
|
margin: (source.width - element.width) / 2 + 220,
|
minDistance: minDistance,
|
},
|
};
|
}
|
return findFreePosition(source, element, position, generateGetNextPosition(nextPositionDirection));
|
}
|
export function getNewShapePosition(source: any, element: any, jnpfData: any) {
|
if (is(element, 'bpmn:TextAnnotation')) return getTextAnnotationPosition(source, element);
|
if (isAny(element, ['bpmn:DataObjectReference', 'bpmn:DataStoreReference'])) return getDataElementPosition(source, element);
|
if (is(element, 'bpmn:FlowNode')) return getFlowNodePosition(source, element, jnpfData);
|
}
|
/**
|
* Always put element bottom right of source.
|
*/
|
export function getDataElementPosition(source: any, element: any) {
|
var sourceTrbl = asTRBL(source);
|
var position = {
|
x: sourceTrbl.right - 10 + element.width / 2,
|
y: sourceTrbl.bottom + 40 + element.width / 2,
|
};
|
var nextPositionDirection = {
|
x: {
|
margin: 30,
|
minDistance: 30,
|
},
|
};
|
return findFreePosition(source, element, position, generateGetNextPosition(nextPositionDirection));
|
}
|
/**
|
* Always try to place text annotations top right of source.
|
*/
|
export function getTextAnnotationPosition(source: any, element: any) {
|
var sourceTrbl = asTRBL(source);
|
var position = {
|
x: sourceTrbl.right + element.width / 2,
|
y: sourceTrbl.top - 50 - element.height / 2,
|
};
|
if (!!source.waypoints) {
|
position = getMid(source);
|
position.x += 100;
|
position.y -= 50;
|
}
|
var nextPositionDirection = {
|
y: {
|
margin: -30,
|
minDistance: 20,
|
},
|
};
|
return findFreePosition(source, element, position, generateGetNextPosition(nextPositionDirection));
|
}
|
export default function YmGridSnappingAutoPlaceBehavior(eventBus: any, gridSnapping: any, jnpfData: any) {
|
eventBus.on('autoPlace', HIGH_PRIORITY, function (context: any) {
|
var source = context.source,
|
sourceMid = getMid(source),
|
shape = context.shape,
|
layout = jnpfData.data['layout']; // horizontal: 横向， vertical：纵向
|
var position: any = getNewShapePosition(source, shape, jnpfData);
|
['x', 'y'].forEach(function (axis: any) {
|
var options: any = {};
|
if (position[axis] === sourceMid[axis]) return;
|
if (position[axis] > sourceMid[axis]) options.min = position[axis];
|
else options.max = position[axis];
|
|
if (is(shape, 'bpmn:TextAnnotation')) {
|
if (isHorizontal(axis)) options.offset = -shape.width / 2;
|
else options.offset = -shape.height / 2;
|
}
|
});
|
if (layout?.value === 'vertical') {
|
if (source.type === bpmnStart) {
|
position = {
|
x: position.x + (source.width - shape.width) / 2 + 10,
|
y: position.y,
|
};
|
} else {
|
position = {
|
x: position.x - 100,
|
y: position.y,
|
};
|
}
|
}
|
return position;
|
});
|
}
|
|
YmGridSnappingAutoPlaceBehavior.$inject = ['eventBus', 'gridSnapping', 'jnpfData'];
|
function isHorizontal(axis: any) {
|
return axis === 'x';
|
}
|
