Lines Matching refs:axis
25800 axis = 'x',
25804 axis = 'y';
25809 axis: axis,
25828 axis = orientation.axis,
25838 return Math.round((first[axis] + last[axis] + last[dimension]) / 2);
25842 alignment[type] = sortedElements[0][axis];
25847 alignment[type] = lastElement[axis] + lastElement[dimension];
25854 var center = element[axis] + Math.round(element[dimension] / 2);
25883 return element[axis] + element[dimension];
25969 [ 'x', 'y' ].forEach(function(axis) { argument
25971 var nextPositionDirectionForAxis = nextPositionDirection[ axis ];
25977 var dimension = axis === 'x' ? 'width' : 'height';
25983 nextPosition[ axis ] = Math.min(
25984 connectedAtPosition[ axis ] + margin - element[ dimension ] / 2,
25985 previousPosition[ axis ] - minDistance + margin
25988 nextPosition[ axis ] = Math.max(
25989 …connectedAtPosition[ axis ] + connectedAtPosition[ dimension ] + margin + element[ dimension ] / 2,
25990 previousPosition[ axis ] + minDistance + margin
29197 function axisAdd(point, axis, delta) { argument
29198 return axisSet(point, axis, point[axis] + delta);
29201 function axisSet(point, axis, value) { argument
29203 x: (axis === 'x' ? value : point.x),
29204 y: (axis === 'y' ? value : point.y)
29208 function axisFenced(position, segmentStart, segmentEnd, axis) { argument
29210 var maxValue = Math.max(segmentStart[axis], segmentEnd[axis]),
29211 minValue = Math.min(segmentStart[axis], segmentEnd[axis]);
29215 var fencedValue = Math.min(Math.max(minValue + padding, position[axis]), maxValue - padding);
29217 return axisSet(segmentStart, axis, fencedValue);
29220 function flipAxis(axis) { argument
29221 return axis === 'x' ? 'y' : 'x';
29273 direction, axis, dragPosition;
29283 axis = direction === 'v' ? 'x' : 'y';
29286 segmentStart = getDocking$2(segmentStart, connection.source, axis);
29290 segmentEnd = getDocking$2(segmentEnd, connection.target, axis);
29310 axis: axis, property in ConnectionSegmentMove.context
29315 cursor: axis === 'x' ? 'resize-ew' : 'resize-ns',
29366 axis = flipAxis(context.axis);
29370 var draggerPosition = axisFenced(event, segmentStart, segmentEnd, axis);
29430 axis = context.axis;
29433 newSegmentStart = axisAdd(segmentStart, axis, event['d' + axis]),
29434 newSegmentEnd = axisAdd(segmentEnd, axis, event['d' + axis]);
29660 function isSnapped(event, axis) { argument
29667 if (typeof axis === 'string') {
29668 return snapped[axis];
29687 function setSnapped(event, axis, value) { argument
29688 if (typeof axis !== 'string') {
29697 previousValue = event[axis];
29703 snapped[axis] = false;
29705 snapped[axis] = true;
29709 event[axis] += delta;
29710 event['d' + axis] += delta;
29779 axis = context.axis;
29809 if (axis === 'y') {
29813 if (axis === 'x') {
36552 this.registerFilter(function(elements, axis, dimension) { argument
36634 axis = this._axis,
36643 distributableElements = filterFn(distributableElements, axis, dimension);
36672 axis = this._axis,
36675 if (!axis) {
36680 var sortedElements = sortBy(elements, axis);
36683 var elementRange = self._findRange(element, axis, dimension),
36738 var axis = element[this._axis],
36742 min: axis + THRESHOLD,
36743 max: axis + dimension - THRESHOLD
37298 [ 'x', 'y' ].forEach(function(axis) { argument
37302 var snapOffset = getSnapOffset(event, axis, elementRegistry);
37309 var snapConstraints = getSnapConstraints(event, axis);
37315 if (!isSnapped(event, axis)) {
37316 self.snapEvent(event, axis, options);
37331 GridSnapping.prototype.snapEvent = function(event, axis, options) { argument
37332 var snappedValue = this.snapValue(event[ axis ], options);
37334 setSnapped(event, axis, snappedValue);
37425 function getSnapConstraints(event, axis) { argument
37433 if (snapConstraints && snapConstraints[ axis ]) {
37434 return snapConstraints[ axis ];
37441 if (!snapConstraints[ axis ]) {
37442 snapConstraints[ axis ] = {};
37449 if (isHorizontal$3(axis)) {
37463 if (isHorizontal$3(axis)) {
37483 if (isHorizontal$3(axis)) {
37502 return snapConstraints[ axis ];
37515 function getSnapOffset(event, axis, elementRegistry) { argument
37523 if (snapOffset && isNumber(snapOffset[ axis ])) {
37524 return snapOffset[ axis ];
37531 if (!isNumber(snapOffset[ axis ])) {
37532 snapOffset[ axis ] = 0;
37536 return snapOffset[ axis ];
37541 if (isHorizontal$3(axis)) {
37542 snapOffset[ axis ] += shape[ axis ] + shape.width / 2;
37544 snapOffset[ axis ] += shape[ axis ] + shape.height / 2;
37549 return snapOffset[ axis ];
37552 if (axis === 'x') {
37554 snapOffset[ axis ] -= shape.width / 2;
37556 snapOffset[ axis ] += shape.width / 2;
37560 snapOffset[ axis ] -= shape.height / 2;
37562 snapOffset[ axis ] += shape.height / 2;
37566 return snapOffset[ axis ];
37569 function isHorizontal$3(axis) { argument
37570 return axis === 'x';
37768 var axis = context.axis;
37772 if (axis === 'x') {
37821 [ 'x', 'y' ].forEach(function(axis) { argument
37825 if (position[ axis ] === sourceMid[ axis ]) {
37829 if (position[ axis ] > sourceMid[ axis ]) {
37830 options.min = position[ axis ];
37832 options.max = position[ axis ];
37837 if (isHorizontal$2(axis)) {
37845 position[ axis ] = gridSnapping.snapValue(position[ axis ], options);
37861 function isHorizontal$2(axis) { argument
37862 return axis === 'x';
43744 axis = context.axis,
43753 if (isHorizontal$1(axis)) {
43781 function isHorizontal$1(axis) { argument
43782 return axis === 'x';
47106 function getDirection(axis, delta) {
47108 if (axis === 'x') {
47118 if (axis === 'y') {
47308 axis = context.axis,
47325 delta[ axis ] = round$4(event[ 'd' + axis ]);
47405 var axis = abs$1(event.dx) > abs$1(event.dy) ? 'x' : 'y',
47406 delta = event[ 'd' + axis ],
47407 start = event[ axis ] - delta;
47423 var direction = getDirection(axis, delta);
47429 var elements = this.calculateAdjustments(children, axis, delta, start);
47432 axis: axis,
47438 …var spaceToolConstraints = getSpaceToolConstraints(elements, axis, direction, start, minDimensions…
47444 axis: axis,
47451 set('resize-' + (axis === 'x' ? 'ew' : 'ns'));
47466 SpaceTool.prototype.calculateAdjustments = function(elements, axis, delta, start) { argument
47477 var shapeStart = element[ axis ],
47478 shapeEnd = shapeStart + element[ AXIS_TO_DIMENSION[ axis ] ];
47568 function getSpaceToolConstraints(elements, axis, direction, start, minDimensions) { argument
47641 resizingShape[ AXIS_TO_DIMENSION [ axis ] ] -
47642 resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
47647 resizingShape[ AXIS_TO_DIMENSION [ axis ] ] -
47648 resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
47653 resizingShape[ AXIS_TO_DIMENSION [ axis ] ] +
47654 resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
47659 resizingShape[ AXIS_TO_DIMENSION [ axis ] ] +
47660 resizingShapeMinDimensions[ AXIS_TO_DIMENSION[ axis ] ];
47764 axis = context.axis,
47874 attr(line, { d: orientation[ axis ] });
47878 delta[ opposite[ context.axis ] ] = 0;
49631 axis = context.axis,
49635 group.range.min = Math.min(element[axis], group.range.min);
49636 group.range.max = Math.max(element[axis] + element[dimension], group.range.max);
49640 return element[axis] + element[dimension] / 2;
49654 delta[axis] = refCenter - center(element);
49656 if (delta[axis]) {
49658 delta[OFF_AXIS[axis]] = 0;
49686 sortedElements = sortBy(group.elements, axis);
49705 min: element[axis],
49706 max: element[axis] + element[dimension]
49742 delta[OFF_AXIS[axis]] = 0;
49743 delta[axis] = (prevGroup.range.max - element[axis]) + margin;
49745 if (group.range.min !== element[axis]) {
49746 delta[axis] += element[axis] - group.range.min;
49749 if (delta[axis]) {
49753 group.range.max = Math.max(element[axis] + element[dimension], idx ? group.range.max : 0);
50549 axis = getAxisFromDirection(direction),
50561 waypoint[ axis ] = waypoint[ axis ] + delta[ axis ];
50567 waypoint.original[ axis ] = waypoint.original[ axis ] + delta[ axis ];
51201 Modeling$1.prototype.distributeElements = function(groups, axis, dimension) { argument
51204 axis: axis, property in AnonymousFunctionf8d14cd15c700.context
53038 function isInRange(axis, a, b) { argument
53044 return inRange(a[axis], b[axis], b[axis] + b[size[axis]]);
53059 var axis = {},
53085 axis[primaryAxis] = end[primaryAxis];
53089 x: axis.x !== undefined ? axis.x : start.x,
53090 y: axis.y !== undefined ? axis.y : start.y,
53092 x: axis.x !== undefined ? axis.x : start.x,
53093 y: axis.y !== undefined ? axis.y : start.y
53108 axis[primaryAxis] = start[primaryAxis];
53116 x: axis.x !== undefined ? axis.x : end.x,
53117 y: axis.y !== undefined ? axis.y : end.y,
53119 x: axis.x !== undefined ? axis.x : end.x,
53120 y: axis.y !== undefined ? axis.y : end.y
53688 function shouldConnectToSameSide(axis, source, target, end) { argument
53692 areCloseOnAxis(axis, end, target, threshold) ||
53693 areCloseOnAxis(axis, end, {
53697 areCloseOnAxis(axis, end, getMid(source), threshold)
53701 function areCloseOnAxis(axis, a, b, threshold) { argument
53702 return Math.abs(a[ axis ] - b[ axis ]) < threshold;
55815 AXES.forEach(function(axis) { argument
55816 var dimensionForAxis = getDimensionForAxis(axis, target);
55818 if (event[ axis ] < target[ axis ] + padding) {
55819 setSnapped(event, axis, target[ axis ] + padding);
55820 } else if (event[ axis ] > target[ axis ] + dimensionForAxis - padding) {
55821 setSnapped(event, axis, target[ axis ] + dimensionForAxis - padding);
55830 AXES.forEach(function(axis) { argument
55831 if (isMid(event, target, axis)) {
55832 setSnapped(event, axis, targetMid[ axis ]);
55859 axes.forEach(function(axis) { argument
55860 var coordinate = event[ axis ], newCoordinate;
55862 if (abs(coordinate - sourceMid[ axis ]) < BOUNDARY_TO_HOST_THRESHOLD) {
55863 if (coordinate > sourceMid[ axis ]) {
55864 newCoordinate = sourceMid[ axis ] + BOUNDARY_TO_HOST_THRESHOLD;
55867 newCoordinate = sourceMid[ axis ] - BOUNDARY_TO_HOST_THRESHOLD;
55870 setSnapped(event, axis, newCoordinate);
55890 function getDimensionForAxis(axis, element) { argument
55891 return axis === 'x' ? element.width : element.height;
55902 function isMid(event, target, axis) { argument
55903 return event[ axis ] > target[ axis ] + TARGET_CENTER_PADDING
55904 && event[ axis ] < target[ axis ] + getDimensionForAxis(axis, target) - TARGET_CENTER_PADDING;
56054 SnapPoints.prototype.snap = function(point, snapLocation, axis, tolerance) { argument
56057 return snappingValues && snapTo(point[axis], snappingValues[axis], tolerance);
56689 forEach([ 'x', 'y' ], function(axis) { argument
56692 if (!snapping[axis]) {
56693 locationSnapping = snapPoints.snap(snapCurrent, location, axis, SNAP_TOLERANCE);
56696 snapping[axis] = {
56698 originValue: locationSnapping - snapOrigin[axis]
56715 forEach([ 'x', 'y' ], function(axis) { argument
56716 var axisSnapping = snapping[axis];
56719 setSnapped(event, axis, axisSnapping.originValue);