Lines Matching refs:x
73 var x = Math.floor(Math.random() * base).toString(base);
74 res = x + res;
79 var x = Math.floor(Math.random() * b).toString(base);
80 res = x + res;
2418 result += p.x + ',' + p.y + ' ';
2679 var x = bbox.x,
2684 if (x < minX || minX === undefined) {
2685 minX = x;
2691 if ((x + width) > maxX || maxX === undefined) {
2692 maxX = x + width;
2700 x: minX,
2733 if (!isNumber(bbox.y) && (e.x > bbox.x)) {
2736 if (!isNumber(bbox.x) && (e.y > bbox.y)) {
2739 if (e.x > bbox.x && e.y > bbox.y) {
2741 e.width + e.x < bbox.width + bbox.x &&
2810 x: 0,
2837 var x = shape.x,
2843 ['M', x, y],
2864 connectionPath.push([ idx === 0 ? 'M' : 'L', point.x, point.y ]);
3053 Math.pow(a.x - b.x, 2) +
3079 var val = (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x),
3145 return Math.abs(firstPoint.x - point.x) <= ALIGNED_THRESHOLD;
3163 return p.x > rect.x - tolerance &&
3165 p.x < rect.x + rect.width + tolerance &&
3179 x: Math.round(p.x + ((q.x - p.x) / 2.0)),
3328 function rectBBox(x, y, width, height) { argument
3331 y = x.y;
3332 width = x.width;
3333 height = x.height;
3334 x = x.x;
3338 x: x,
3342 x2: x + width,
3363 x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x,
3367 x: fixError(x),
3384 function isPointInsideBBox$2(bbox, x, y) { argument
3385 return x >= bbox.x &&
3386 x <= bbox.x + bbox.width &&
3394 return isPointInsideBBox$2(bbox2, bbox1.x, bbox1.y)
3396 || isPointInsideBBox$2(bbox2, bbox1.x, bbox1.y2)
3398 || isPointInsideBBox$2(bbox1, bbox2.x, bbox2.y)
3400 || isPointInsideBBox$2(bbox1, bbox2.x, bbox2.y2)
3402 || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x
3403 || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x)
3478 return { x: px, y: py };
3506 dots1.push({ x: p.x, y: p.y, t: i / n1 });
3511 dots2.push({ x: p.x, y: p.y, t: i / n2 });
3521 ci = abs$7(di1.x - di.x) < .01 ? 'y' : 'x',
3522 cj = abs$7(dj1.x - dj.x) < .01 ? 'y' : 'x',
3523 is = intersectLines(di.x, di.y, di1.x, di1.y, dj.x, dj.y, dj1.x, dj1.y),
3527 key = is.x.toFixed(9) + '#' + is.y.toFixed(9);
3544 x: is.x,
3672 x = 0,
3680 x = +pathArray[0][1];
3682 mx = x;
3685 res[0] = ['M', x, y];
3703 r[6] = +pa[6] + x;
3710 r[1] = +pa[1] + x;
3713 mx = +pa[1] + x;
3717 r[j] = +pa[j] + ((j % 2) ? x : y);
3729 x = +mx;
3733 x = r[1];
3742 x = r[r.length - 2];
3791 rotate = cacher(function(x, y, rad) { argument
3792 var X = x * math.cos(rad) - y * math.sin(rad),
3793 Y = x * math.sin(rad) + y * math.cos(rad);
3795 return { x: X, y: Y };
3800 x1 = xy.x;
3803 x2 = xy.x;
3806 var x = (x1 - x2) / 2,
3809 var h = (x * x) / (rx * rx) + (y * y) / (ry * ry);
3820 … math.sqrt(abs$7((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),
3822 cy = k * -ry * x / rx + (y1 + y2) / 2,
3881 newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x;
3979 attrs = { x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null }, property in pathToCurve.attrs
3984 return ['C', d.x, d.y, d.x, d.y, d.x, d.y];
3995 path = ['C'].concat(arcToCurve.apply(0, [d.x, d.y].concat(path.slice(1))));
4001 nx = d.x * 2 - d.bx;
4011 nx = d.x;
4020 d.qx = d.x * 2 - d.qx;
4030 d.qx = d.x;
4033 path = ['C'].concat(qubicToCurve(d.x, d.y, d.qx, d.qy, path[1], path[2]));
4038 path = ['C'].concat(qubicToCurve(d.x, d.y, path[1], path[2], path[3], path[4]));
4041 path = ['C'].concat(lineToCurve(d.x, d.y, path[1], path[2]));
4044 path = ['C'].concat(lineToCurve(d.x, d.y, path[1], d.y));
4047 path = ['C'].concat(lineToCurve(d.x, d.y, d.x, path[1]));
4050 path = ['C'].concat(lineToCurve(d.x, d.y, d.X, d.Y));
4096 attrs.x = seg[seglen - 2];
4098 attrs.bx = toFloat(seg[seglen - 4]) || attrs.x;
4112 x: Math.round(bounds.x),
4123 x: Math.round(point.x),
4139 right: bounds.x + (bounds.width || 0),
4141 left: bounds.x
4155 x: trbl.left,
4172 x: bounds.x + (bounds.width || 0) / 2,
4200 padding = { x: padding, y: padding }; property in getOrientation.padding
4208 right = rectOrientation.left - padding.x >= referenceOrientation.right,
4210 left = rectOrientation.right + padding.x <= referenceOrientation.left;
5242 x, y;
5255 x = round$b(-matrix.e || 0, 1000);
5259 x: x ? x / scale : 0,
5267 x: innerBox.x,
5281 .translate(-box.x, -box.y);
5314 return { x: matrix.e, y: matrix.f };
5356 viewboxBounds.x += padding.left / zoom;
5367 dx = elementBounds.x - viewboxBounds.x;
5417 x: outer.width / 2, property in AnonymousFunctionf8d14cd17b00.AnonymousFunctionf8d14cd17c00.center
5448 if (inner.x >= 0 &&
5450 inner.x + inner.width <= outer.width &&
5455 x: 0,
5457 width: Math.max(inner.width + inner.x, outer.width),
5464 x: inner.x + (center ? inner.width / 2 - outer.width / newScale / 2 : 0),
5503 .translate(originalPoint.x, originalPoint.y)
5505 .translate(-originalPoint.x, -originalPoint.y);
5559 var x = bbox.x * vbox.scale - vbox.x * vbox.scale;
5566 x: x,
6980 function transform(gfx, x, y, angle, amount) { argument
6982 translate.setTranslate(x, y);
6999 function translate$2(gfx, x, y) { argument
7001 translate.setTranslate(x, y);
7203 translate$2(gfx, element.x, element.y);
8362 function replaceEntities(_, d, x, z) { argument
8381 return fromCharCode(parseInt(x, 16));
8668 x, y, q, w, v,
9209 for (x = i + 1; ; x++) {
9210 v = xml.charCodeAt(x);
9221 q = xml.indexOf('"', x + 1);
9222 x = q !== -1 ? q : x;
9224 q = xml.indexOf("'", x + 1);
9225 x = q !== -1 ? q : x;
9227 j = x;
9262 x = elementName = nodeStack.pop();
9263 q = i + 2 + x.length;
9265 if (xml.substring(i + 2, q) !== x) {
9282 x = elementName = xml.substring(i + 1, j - 1);
9288 x = elementName = xml.substring(i + 1, j);
9298 for (q = 1, y = x.length; q < y; q++) {
9299 w = x.charCodeAt(q);
9306 elementName = x.substring(0, q);
9338 if ((maybeNS = x.indexOf('xmlns', q) !== -1)) {
9340 attrsString = x;
9381 attrsString = x;
16040 … 'viewBox="' + bbox.x + ' ' + bbox.y + ' ' + bbox.width + ' ' + bbox.height + '" version="1.1">' +
16643 var cx = shape.x + shape.width / 2,
16660 var x = shape.x,
16666 ['M', x + borderRadius, y],
16685 x = shape.x,
16691 ['M', x + halfWidth, y],
16702 var x = shape.x,
16708 ['M', x, y],
16752 var ref = options.ref || { x: 0, y: 0 };
16771 refX: ref.x,
16815 ref: { x: 11, y: 10 },
16834 ref: { x: 6, y: 6 }
16849 ref: { x: 8.5, y: 5 }
16864 ref: { x: 1, y: 10 },
16880 ref: { x: 12, y: 10 },
16895 ref: { x: -1, y: 10 },
16909 ref: { x: 0, y: 10 },
16967 x: offset,
16986 var points = [{ x: x_2, y: 0 }, { x: width, y: y_2 }, { x: x_2, y: height }, { x: 0, y: y_2 }];
16989 return point.x + ',' + point.y;
17145 x: element.width / 2 + element.x, property in BpmnRenderer.renderExternalLabel.box
17182 var pathData = 'm ' + waypoints[0].x + ',' + waypoints[0].y;
17184 pathData += 'L' + waypoints[i].x + ',' + waypoints[i].y + ' ';
17542 x: 12,
17555 x: 17.2,
17567 x: 17,
17583 var x = 15;
17588 x: x,
17601 x: x,
17614 x: x,
17632 x: 17,
17678 x: 7.77,
17709 x: 15,
17726 x: 8,
17740 x: 8,
17812 { x: 30, y: 0 },
17813 { x: 30, y: element.height }
18123 x: midPoint.x,
18152 var translateX = midPoint.x - labelBounds.width / 2,
18636 width: textBBox.width + textBBox.x * 2,
18857 attr(helperText, { x: 0, y: 0 });
18899 var x;
18905 x = padding.left;
18909 x = ((fitBox ? maxLineWidth : maxWidth)
18916 x = Math.max((((fitBox ? maxLineWidth : maxWidth)
18921 attr(tspan, { x: x, y: y });
18988 x: bounds.width / 2 + bounds.x,
18996 x: Math.round(bounds.x + bounds.width / 2 - layoutedDimensions.width / 2),
19022 x: bounds.x,
19467 mx = param.abspos.x;
19625 var angle = Math.atan((second.y - first.y) / (second.x - first.x));
19627 var x = position.x,
19633 x += FLOW_LABEL_INDENT;
19636 return { x: x, y: y };
19654 x: first.x + (second.x - first.x) / 2,
19666 x: element.x + element.width / 2,
19671 x: element.x + element.width / 2,
19702 x: bounds.x + bounds.width / 2, property in getExternalLabelBounds.mid
19713 x: mid.x - size.width / 2,
19739 return { x: p.x, y: p.y };
19820 x: Math.round(bounds.x),
19955 x: Math.round(bounds.x),
20023 var x = point.x,
20026 return x >= bbox.x &&
20027 x <= bbox.x + bbox.width &&
20081 x: event.clientX,
20467 x: 0,
20636 x: 10,
20687 x: -this.offset,
20708 x: bbox.x - this.offset,
21335 var x = element.x,
21340 x = bbox.x;
21344 setPosition$1(html, x, y);
21421 -1 * viewbox.x * scale,
21658 function setPosition$1(el, x, y) { argument
21659 assign(el.style, { left: x + 'px', top: y + 'px' });
22317 x: bounds.x + (bounds.width / 2),
22325 x: a.x - b.x,
22376 dx: delta$1.x,
22440 return Math.sqrt(Math.pow(point.x, 2) + Math.pow(point.y, 2));
22452 function log10(x) { argument
22453 return Math.log(x) / Math.log(10);
22591 x: event.clientX - elementRect.left,
23286 input.overallVelocityX = overallVelocity.x;
23288 …input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : ov…
23314 x: prevInput.deltaX || 0,
23319 x: center.x,
23324 input.deltaX = prevDelta.x + (center.x - offset.x);
23343 velocityX = v.x;
23345 velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;
23401 x: round(pointers[0].clientX),
23406 var x = 0, y = 0, i = 0;
23408 x += pointers[i].clientX;
23414 x: round(x / pointersLength),
23426 function getVelocity(deltaTime, x, y) { argument
23428 x: x / deltaTime || 0,
23439 function getDirection(x, y) { argument
23440 if (x === y) {
23444 if (abs(x) >= abs(y)) {
23445 return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
23461 var x = p2[props[0]] - p1[props[0]],
23464 return Math.sqrt((x * x) + (y * y));
23478 var x = p2[props[0]] - p1[props[0]],
23480 return Math.atan2(y, x) * 180 / Math.PI;
23890 var lastTouch = {x: touch.clientX, y: touch.clientY}; property in setLastTouch.lastTouch
23904 var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;
23907 var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);
24511 var x = input.deltaX;
24517 … direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;
24518 hasMoved = x != this.pX;
25612 var node = document.elementFromPoint(position.x, position.y),
25717 x: -10000,
25728 x: 10000,
25760 return element.x;
25774 return element.x + element.width;
25965 x: previousPosition.x, property in generateGetNextPosition.AnonymousFunctionf8d14cd125f00.nextPosition
26008 x: position.x - (element.width / 2), property in getConnectedAtPosition.bounds
26077 return asTRBL(a).left - getMid(b).x;
26093 return getMid(b).x - asTRBL(a).right;
26299 x: sourceTrbl.right + distance + element.width / 2,
26419 x: sourceTrbl.right + horizontalDistance + element.width / 2, property in getFlowNodePosition.position
26453 x: sourceTrbl.right + element.width / 2, property in getTextAnnotationPosition.position
26476 x: sourceTrbl.right - 10 + element.width / 2, property in getDataElementPosition.position
26481 x: { class in getDataElementPosition.nextPositionDirection
26875 newBounds.x !== oldBounds.x ||
27246 target = document.elementFromPoint(position.x, position.y);
27290 return Math.sqrt(Math.pow(point.x, 2) + Math.pow(point.y, 2));
27392 x: viewbox.x + (globalPosition.x - clientRect.left) / viewbox.scale,
27449 x: round$a(localStart.x + displacement.x),
27484 x: round$a(localCurrent.x + displacement.x),
27486 dx: round$a(localDelta.x),
27718 globalStart = { x: 0, y: 0 }; property in Dragging.globalStart
27876 point.x,
27878 clientRect.width - point.x,
27949 x: globalPosition.x - clientRect.left,
28019 var x = center.x,
28023 ['M', x, y],
28035 segments.push([ idx === 0 ? 'M' : 'L', p.x, p.y ]);
28094 x: (round$9(a.x + b.x) / 2),
28103 x: round$9(a.x),
28134 x: clientRect.left,
28143 x: viewbox.x + (position.x - offset.x) / viewbox.scale,
28201 x: -width / 2,
28212 x: -hitWidth / 2,
28240 translate$2(groupGfx, mid.x, mid.y);
28258 var segmentLengthXAxis = segmentEnd.x - segmentStart.x,
28414 xDelta = Math.abs(p.x - mid.x);
28444 segmentLength = relevantSegment.end.x - relevantSegment.start.x;
28517 translate$2(bendpoint, p.x, p.y);
28593 translate$2(floating, point.x, point.y);
28614 x: point.x - mid.x,
28622 x: relativePosition.y,
28623 y: relativePosition.x
28627 translate$2(draggerVisual, relativePosition.x, relativePosition.y);
28900 x: round$8(event.x), property in AnonymousFunctionf8d14cd12ac00.docking
29033 newWaypoints.splice(bendpointIndex, 0, { x: event.x, y: event.y });
29095 bendpoint = { x: event.x, y: event.y }, property in eventBus.AnonymousFunctionf8d14cd12b100.bendpoint
29153 translate$2(draggerGfx, event.x, event.y);
29203 x: (axis === 'x' ? value : point.x),
29299 x: (segmentStart.x + segmentEnd.x) / 2, property in ConnectionSegmentMove.dragPosition
29373 translate$2(context.draggerGfx, draggerPosition.x, draggerPosition.y);
29563 x: Math.round(p.x),
29626 x: bounds.x,
29633 x: bounds.x + bounds.width,
29640 if (!bounds || isNaN(bounds.x) || isNaN(bounds.y)) {
29645 x: round$7(bounds.x + bounds.width / 2),
29671 return snapped.x && snapped.y;
29762 x: round$6(element.width / 2 + element.x),
29814 snapPoints.vertical.push(p.x);
29825 x = event.x,
29834 sx = snapTo(snapPoints.vertical, x);
29839 var cx = (x - sx),
29846 x: sx,
29851 if (cx || snapPoints.vertical.indexOf(x) !== -1) {
29885 snapPoints.vertical.push(p.x);
29899 x = event.x,
29908 sx = snapTo(hoverMid ? snapPoints.vertical.concat([ hoverMid.x ]) : snapPoints.vertical, x);
29912 var cx = (x - sx),
29919 x: event.x - cx,
29924 if (cx || snapPoints.vertical.indexOf(x) !== -1) {
30019 x: event.x, property in AnonymousFunctionf8d14cd12c200.connectionEnd
30116 x: event.x,
30411 attr(connection, { 'points': [ start.x, start.y, end.x, end.y ] });
30573 left: bounds.x + 'px',
31010 x: newBounds.left - containerBounds.left,
31536 x: bbox.top,
31559 x: shape.x,
31843 x: event.x, property in AnonymousFunctionf8d14cd130800.position
31886 x: event.x, property in AnonymousFunctionf8d14cd130a00.position
31961 if (!isNumber(element.x)) {
31962 element.x = 0;
31977 x: waypoint.x - bbox.x - bbox.width / 2,
31984 x: element.x - bbox.x - bbox.width / 2,
32020 event.x = Math.max(event.x, createConstraints.left);
32024 event.x = Math.min(event.x, createConstraints.right);
32083 translate$2(gfx, element.x, element.y);
32114 translate$2(dragGroup, event.x, event.y);
32497 left: position.x + 'px',
32592 x: cursor.x - clientRect.left,
32597 overAxis.x = true;
32604 if (overAxis.x && overAxis.y) {
32605 left = cursorPosition.x - containerWidth + 'px';
32607 } else if (overAxis.x) {
32608 left = cursorPosition.x - containerWidth + 'px';
32611 left = cursorPosition.x + 'px';
32614 left = cursorPosition.x + 'px';
32786 function createMoveEvent(x, y) { argument
32789 var screenX = x,
32791 clientX = x,
33053 if (!isNumber(element.x)) {
33054 element.x = 0;
33069 x: waypoint.x - bbox.x - bbox.width / 2,
33076 x: element.x - bbox.x - bbox.width / 2,
33906 x = newElementData.x || oldElement.x,
33908 centerX = round$5(x + width / 2),
33920 x: centerX,
34170 newElement.x = element.x + (element.width - newElement.width) / 2;
35751 var dx = delta.x,
35755 x: bounds.x, property in resizeBounds$1.newBounds
35771 newBounds.x = bounds.x + dx;
35790 x: bounds.x + (resize.left || 0),
35876 x: bbox.x - left,
36182 x: left, property in AnonymousFunctionf8d14cd138900.getReplaceMenuPosition.pos
36403 cursor: { x: event.x, y: event.y }
37203 { x: -boundingBox.x, y: -boundingBox.y },
37450 snapConstraints.x.min = createConstraints.left;
37451 snapConstraints.x.max = createConstraints.right;
37466 snapConstraints.x.max = minResizeConstraints.left;
37468 snapConstraints.x.min = minResizeConstraints.right;
37486 snapConstraints.x.min = maxResizeConstraints.left;
37488 snapConstraints.x.max = maxResizeConstraints.right;
37638 newBounds.x = shape.x + (shape.width / 2) - (newBounds.width / 2);
37687 snappedNewBounds.x = gridSnapping.snapValue(newBounds.x, {
37688 max: newBounds.x
37691 snappedNewBounds.width += gridSnapping.snapValue(newBounds.x - snappedNewBounds.x, {
37692 min: newBounds.x - snappedNewBounds.x
37698 newBounds.x = newBounds.x + newBounds.width - snappedNewBounds.width;
37777 event.x = event.x + snapped - event.dx;
38024 snapped.x = gridSnapping.snapValue(segmentStart.x);
38351 x: -speed,
38357 x: 0,
38363 x: speed,
38369 x: 0,
38675 x: event.dx, property in AnonymousFunctionf8d14cd13eb00.delta
38766 return shape.x !== newBounds.x ||
38777 x: mid.x, property in getReferencePoint$1.referencePoint
38788 referencePoint.x = trbl.right;
38790 referencePoint.x = trbl.left;
38843 attr(frame, { x: bounds.x, width: bounds.width });
38955 ResizeHandles.prototype._createResizer = function(element, x, y, direction) { argument
38971 x: -HANDLE_SIZE / 2 + offset.x,
38984 x: -HANDLE_HIT_SIZE / 2 + offset.x,
38994 transform(group, x, y);
39002 var resizer = this._createResizer(element, point.x, point.y, direction);
39052 x: 0, property in getHandleOffset.offset
39057 offset.x = -HANDLE_OFFSET;
39059 offset.x = HANDLE_OFFSET;
39290 x: bbox.x + bbox.width / 2, property in AnonymousFunctionf8d14cd140200.mid
39295 var bounds = { x: bbox.x, y: bbox.y }; property in AnonymousFunctionf8d14cd140200.bounds
39319 x: bbox.x - bbox.height / 2 + (15 * zoom),
39361 x: bbox.x
39383 x: mid.x - width / 2,
39403 x: externalLabelMid.x,
39414 x: absoluteBBox.x - width / 2,
39462 x: element.x, property in AnonymousFunctionf8d14cd140300.newBounds
39565 translate$2(gfx, element.x, element.y);
39755 x: elementMid.x, property in AdaptiveLabelPositioningBehavior.adjustLabelPosition.case
39764 x: elementTrbl.left - ELEMENT_LABEL_DISTANCE - label.width / 2, property in AdaptiveLabelPositioningBehavior.adjustLabelPosition.case
39773 x: elementMid.x, property in AdaptiveLabelPositioningBehavior.adjustLabelPosition.case
39782 x: elementTrbl.right + ELEMENT_LABEL_DISTANCE + label.width / 2, property in AdaptiveLabelPositioningBehavior.adjustLabelPosition.case
39926 x: source.x + source.width / 2 + 75, property in context.position
39931 x: source.x + source.width + 80 + shape.width / 2, property in context.position
39959 modeling.moveConnection(association, { x: 0, y: 0 }, newParent);
40593 modeling.moveElements(processChildren, { x: 0, y: 0 }, shape);
40642 modeling.moveElements(processChildren, { x: 0, y: 0 }, participant);
40669 x: -width / 2,
41121 { x: 0, y: offset }, 's');
41131 { x: 0, y: -offset }, 'n');
41366 x: shapeMid.x + delta.x, property in DropOnFlowBehavior.AnonymousFunctionf8d14cd145400.newShapeMid
41432 var x = point.x,
41435 return x >= bbox.x &&
41436 x <= bbox.x + bbox.width &&
41736 denominator = ((l2e.y - l2s.y) * (l1e.x - l1s.x)) - ((l2e.x - l2s.x) * (l1e.y - l1s.y));
41743 b = l1s.x - l2s.x;
41744 numerator = ((l2e.x - l2s.x) * a) - ((l2e.y - l2s.y) * b);
41751 x: Math.round(l1s.x + (c * (l1e.x - l1s.x))),
41766 x: elementMid.x, property in ImportDockingFix.adjustDocking.elementTop
41771 x: elementMid.x - 50, property in ImportDockingFix.adjustDocking.elementLeft
41828 return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
41869 return Math.sqrt(Math.pow(v.x, 2) + Math.pow(v.y, 2));
41883 return Math.atan((line[1].y - line[0].y) / (line[1].x - line[0].x));
41896 x: Math.cos(angle) * vector.x - Math.sin(angle) * vector.y,
41897 y: Math.sin(angle) * vector.x + Math.cos(angle) * vector.y
41939 var bd = { x: b.x - a.x, y: b.y - a.y }; property in perpendicularFoot.bd
41942 var r = solveLambaSystem([ a.x, a.y ], [ bd.x, bd.y ], [ point.x, point.y ]);
41944 return { x: a.x + r*bd.x, y: a.y + r*bd.y };
41961 x: pfPoint.x - point.x, property in getDistancePointLine.connectionVector
41979 x: point1.x - point2.x,
42009 return sqrt(sq(p1.x - p2.x) + sq(p1.y - p2.y));
42119 var baX = s2.x - s1.x;
42121 var caX = cc.x - s1.x;
42150 x: s1.x - baX * abScalingFactor1, property in getCircleSegmentIntersections.i1
42159 x: s1.x - baX * abScalingFactor2, property in getCircleSegmentIntersections.i2
42172 fenced(p.x, segmentStart.x, segmentEnd.x) &&
42199 x: (p1.x + p2.x) / 2,
42209 abs$3(p1.x - p2.x) <= EQUAL_THRESHOLD &&
42307 var x = 0,
42318 return { x: x, y: y };
42325 return { x: x, y: y };
42344 return { x: x, y: y };
42352 x: newBendpoint.x - attachment.position.x,
42364 x: (newLabelLine[1].x - newLabelLine[0].x) * relativeFootPosition + newLabelLine[0].x, property in getLabelAdjustment.newFoot
42370 x: labelPosition.x - oldFoot.x,
42375 x = newFoot.x + newLabelVector.x - labelPosition.x;
42379 x: x,
42399 x: label.x + label.width / 2,
42437 x: oldDelta.x * (newBounds.width / oldBounds.width), property in getNewAttachPoint.newDelta
42442 x: newCenter.x + newDelta.x,
42471 x: oldCenterDelta.x * (newBounds.width / oldBounds.width), property in getNewAttachShapeDelta.newCenterDelta
42476 x: newCenter.x + newCenterDelta.x, property in getNewAttachShapeDelta.newShapeCenter
42481 x: newShapeCenter.x + shapeDelta.x - shape.x,
42501 x: 0,
42506 x: 0,
42511 x: newTRBL.left - oldTRBL.left,
42516 x: newTRBL.right - oldTRBL.right,
42526 x: oldShapeCenter.x + stickyPositionDelta.x,
42592 x: element.x,
42682 x: element.x,
42752 newShape.label.x = oldShape.label.x;
42844 x: bounds.x,
42848 x: bounds.x + (bounds.width || 0),
42854 x: bounds.x + (bounds.width || 0),
42858 x: bounds.x + (bounds.width || 0),
42864 x: bounds.x,
42868 x: bounds.x + (bounds.width || 0),
42874 x: bounds.x,
42878 x: bounds.x,
42960 x: bounds.x - delta.x,
43090 x: position.x + 5,
43886 x: shape.x + shape.width / 6,
43927 newBounds.x = visibleBBox.x + (visibleBBox.width - newBounds.width) / 2;
43932 newBounds.x = shape.x + (shape.width - newBounds.width) / 2;
43942 x: shape.x + (shape.width - defaultSize.width) / 2,
46118 function setPosition(el, x, y) { argument
46119 assign(el.style, { left: x + 'px', top: y + 'px' });
46358 …var matrix = 'matrix(' + a + ',0,0,' + d + ',' + (-1 * viewbox.x * a) + ',' + (-1 * viewbox.y * d)…
46412 setPosition(htmlContainer, position.x, position.y);
47186 var x = bounds.x,
47190 dx = delta.x,
47196 x: x,
47203 x: x,
47210 x: x + dx,
47217 x: x,
47231 x: 'width',
47321 x: 0, property in eventBus.AnonymousFunctionf8d14cd151600.delta
47537 var x, y;
47540 x = Math.max(event.x, spaceToolConstraints.left);
47542 event.dx = event.dx + x - event.x;
47543 event.x = x;
47547 x = Math.min(event.x, spaceToolConstraints.right);
47549 event.dx = event.dx + x - event.x;
47550 event.x = x;
47716 x: 'M 0,-10000 L 0,10000', property in AnonymousFunctionf8d14cd152400.orientation
47727 attr(pathX, 'd', orientation.x);
47746 translate$2(crosshairGroup, event.x, event.y);
47870 x: 'M' + event.x + ', -10000 L' + event.x + ', 10000', property in AnonymousFunctionf8d14cd152700.orientation
47876 var opposite = { x: 'y', y: 'x' }; property in AnonymousFunctionf8d14cd152700.opposite
47877 var delta = { x: event.dx, y: event.dy }; property in AnonymousFunctionf8d14cd152700.delta
47881 translate$2(context.dragGroup, delta.x, delta.y);
47892 width: max(initialBounds.width + delta.x, 5)
47895 width = max(initialBounds.width - delta.x, 5);
47899 x: initialBounds.x + initialBounds.width - width
48424 x: shape.x,
49037 x: 0, property in AnonymousFunctionf8d14cd155a00.AnonymousFunctionf8d14cd155b00.delta
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;
49218 if (!isNumber(element.x)) {
49219 element.x = 0;
49234 x: round$3(waypoint.x - bbox.x - bbox.width / 2 + position.x),
49241 x: round$3(element.x - bbox.x - bbox.width / 2 + position.x),
49348 x: positionOrBounds.x - round$2(shape.width / 2),
49623 x: 'y',
49826 p.x += delta.x;
49830 p.original.x += delta.x;
49857 p.x -= delta.x;
49861 p.original.x -= delta.x;
50047 x: shape.x + delta.x,
50095 x: shape.x - delta.x,
50267 x: newData.x,
50272 x: oldShape.x,
50293 modeling.moveElements(children, { x: 0, y: 0 }, newShape, hints);
50386 if (newBounds.x === undefined || newBounds.y === undefined ||
50403 x: shape.x, property in context.oldBounds
50411 x: newBounds.x,
50452 x: oldBounds.x,
50647 x: shape.x,
51755 x: shape.x + LANE_INDENTATION,
51792 { x: 0, y: offset },
51799 x: shape.x + (isRoot ? LANE_INDENTATION : 0),
51864 x: shape.x + LANE_INDENTATION, property in AnonymousFunctionf8d14cd15e800.laneBounds
51983 …spaceTool.makeSpace(adjustments.movingShapes, adjustments.resizingShapes, { x: 0, y: change }, dir…
51990 spacePos = shape.x + (trblDiff.right ? shape.width : 0) + (trblDiff.right ? -10 : 100);
51997 …spaceTool.makeSpace(adjustments.movingShapes, adjustments.resizingShapes, { x: change, y: 0 }, dir…
52032 x: element.x + element.width / 2, property in AnonymousFunctionf8d14cd15ee00.isInLaneShape.elementMid
52036 return elementMid.x > laneTrbl.left &&
52037 elementMid.x < laneTrbl.right &&
52376 x: labelCenter.x, property in UpdateLabelHandler.preExecute.labelCenter
52710 var xmid = round$1((b.x - a.x) / 2 + a.x),
52722 segmentEnd = layoutHorizontal ? { x: xmid, y: a.y } : { x: a.x, y: ymid };
52736 x: a.x + MIN_SEGMENT_LENGTH * (/l/.test(startDirection) ? -1 : 1), property in getSegmentBendpoints.segmentEnd
52740 turnNextDirections = xmid === a.x;
52743 x: turnNextDirections ? xmid + MIN_SEGMENT_LENGTH : xmid, property in getSegmentBendpoints.segmentEnd
52750 x: xmid, property in getSegmentBendpoints.segmentEnd
52813 var xmid = round$1((b.x - a.x) / 2 + a.x),
52818 return [ { x: b.x, y: a.y } ];
52823 return [ { x: a.x, y: b.y } ];
52829 { x: xmid, y: a.y },
52830 { x: xmid, y: b.y }
52837 { x: a.x, y: ymid },
52838 { x: b.x, y: ymid }
53040 x: 'width', property in isInRange.size
53089 x: axis.x !== undefined ? axis.x : start.x,
53092 x: axis.x !== undefined ? axis.x : start.x,
53097 x: end.x,
53112 x: start.x,
53116 x: axis.x !== undefined ? axis.x : end.x,
53119 x: axis.x !== undefined ? axis.x : end.x,
53198 return { x: newPeer.x, y: candidate.y };
53202 return { x: candidate.x, y: newPeer.y };
53205 return { x: candidate.x, y: candidate. y };
53345 return { original: point, x: point.x, y: rectangle.y };
53349 return { original: point, x: rectangle.x + rectangle.width, y: point.y };
53353 return { original: point, x: point.x, y: rectangle.y + rectangle.height };
53357 return { original: point, x: rectangle.x, y: point.y };
53653 x: source.width / 2 + target.width / 2,
53694 x: target.x + target.width,
53898 x: element.x + round(element.width / 2),
53994 delta = { x: event.dx, y: event.dy }, property in AnonymousFunctionf8d14cd161c00.delta
53995 position = { x: event.x, y: event.y }, property in AnonymousFunctionf8d14cd161c00.position
54029 delta.x = round(delta.x);
54032 if (delta.x === 0 && delta.y === 0) {
54858 x: 0,
54870 x: bbox.x,
55018 x: event.x - event.dx, property in toBBox.start
55023 x: event.x, property in toBBox.end
55029 if ((start.x <= end.x && start.y < end.y) ||
55030 (start.x < end.x && start.y <= end.y)) {
55033 x: start.x, property in toBBox.bbox
55035 width: end.x - start.x,
55038 } else if ((start.x >= end.x && start.y < end.y) ||
55039 (start.x > end.x && start.y <= end.y)) {
55042 x: end.x, property in toBBox.bbox
55044 width: start.x - end.x,
55047 } else if ((start.x <= end.x && start.y > end.y) ||
55048 (start.x < end.x && start.y >= end.y)) {
55051 x: start.x, property in toBBox.bbox
55053 width: end.x - start.x,
55056 } else if ((start.x >= end.x && start.y > end.y) ||
55057 (start.x > end.x && start.y >= end.y)) {
55060 x: end.x, property in toBBox.bbox
55062 width: start.x - end.x,
55068 x: end.x, property in toBBox.bbox
55311 x: event.x, property in eventBus.AnonymousFunctionf8d14cd166400.startPosition
55465 x: 0,
55472 x: 40,
55635 assign(newElement, { x: element.x, y: element.y });
55876 setSnapped(event, 'x', position.x);
56041 snapValues = this._snapValues[snapLocation] = { x: [], y: [] };
56044 if (snapValues.x.indexOf(point.x) === -1) {
56045 snapValues.x.push(point.x);
56163 x: event.x + mid$2(shape).x, property in AnonymousFunctionf8d14cd168600.shapeMid
56169 x: shapeMid.x - shape.width / 2, property in AnonymousFunctionf8d14cd168600.shapeTopLeft
56173 x: shapeMid.x + shape.width / 2, property in AnonymousFunctionf8d14cd168600.shapeBottomRight
56178 x: shapeMid.x - event.x,
56188 x: shapeTopLeft.x - event.x,
56193 x: shapeBottomRight.x - event.x,
56237 if (!isNumber(shape.x) || !isNumber(shape.y)) {
56418 offset = { x: 0, y: 0 }; property in snapBoundaryEvent.offset
56430 setSnapped(event, 'x', targetTRBL.left - offset.x);
56432 setSnapped(event, 'x', targetTRBL.right - offset.x);
56464 if ((left && left >= event.x) || (right && right <= event.x)) {
56465 setSnapped(event, 'x', event.x);
56480 x: docking.x - event.x,
56484 x: docking.x,
56532 setSnapped(event, 'x', event.x);
56560 x: snapOrigin.x - event.x,
56601 x: mid.x, property in getSnapOrigin.snapOrigin
56612 snapOrigin.x = trbl.right;
56614 snapOrigin.x = trbl.left;
56676 x: isSnapped(event, 'x'), property in AnonymousFunctionf8d14cd169f00.snapping
56684 x: event.x + snapOrigin.x, property in AnonymousFunctionf8d14cd169f00.AnonymousFunctionf8d14cd16a000.snapCurrent
56705 if (snapping.x && snapping.y) {
56711 this.showSnapLine('vertical', snapping.x && snapping.x.value);