Lines Matching refs:x
198 x: 0,
221 x: nu,
240 pipe = function (x) { argument
241 return x;
243 rectPath = R._rectPath = function (x, y, w, h, r) { argument
245 …return [["M", x + r, y], ["l", w - r * 2, 0], ["a", r, r, 0, 0, 1, r, r], ["l", 0, h - r * 2], ["a…
247 return [["M", x, y], ["l", w, 0], ["l", 0, h], ["l", -w, 0], ["z"]];
249 ellipsePath = function (x, y, rx, ry) { argument
253 …return [["M", x, y], ["m", 0, -ry], ["a", rx, ry, 0, 1, 1, 0, 2 * ry], ["a", rx, ry, 0, 1, 1, 0, -…
269 return rectPath(a.x, a.y, a.width, a.height, a.r);
273 return rectPath(a.x, a.y, a.width, a.height);
277 return rectPath(bbox.x, bbox.y, bbox.width, bbox.height);
281 return rectPath(bbox.x, bbox.y, bbox.width, bbox.height);
298 var x, y, i, j, ii, jj, pathi;
303 x = matrix.x(pathi[j], pathi[j + 1]);
305 pathi[j] = x;
425 var x = x1 - x2,
427 if (!x && !y) {
430 return (180 + math.atan2(-y, -x) * 180 / PI + 360) % 360;
987 function round(x) { return (x + 0.5) | 0; } argument
1025 {x: +crp[i - 2], y: +crp[i - 1]},
1026 {x: +crp[i], y: +crp[i + 1]},
1027 {x: +crp[i + 2], y: +crp[i + 3]},
1028 {x: +crp[i + 4], y: +crp[i + 5]}
1032 p[0] = {x: +crp[iLen - 2], y: +crp[iLen - 1]}; property in catmullRom2bezier.p
1034 p[3] = {x: +crp[0], y: +crp[1]}; property in catmullRom2bezier.p
1036 p[2] = {x: +crp[0], y: +crp[1]}; property in catmullRom2bezier.p
1037 p[3] = {x: +crp[2], y: +crp[3]}; property in catmullRom2bezier.p
1043 p[0] = {x: +crp[i], y: +crp[i + 1]}; property in catmullRom2bezier.p
1047 (-p[0].x + 6 * p[1].x + p[2].x) / 6,
1049 (p[1].x + 6 * p[2].x - p[3].x) / 6,
1051 p[2].x,
1216 x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x,
1229 x: x,
1231 m: {x: mx, y: my},
1232 n: {x: nx, y: ny},
1233 start: {x: ax, y: ay},
1234 end: {x: cx, y: cy},
1274 x: bbox.min.x,
1276 x2: bbox.max.x,
1278 width: bbox.max.x - bbox.min.x,
1295 R.isPointInsideBBox = function (bbox, x, y) { argument
1296 return x >= bbox.x && x <= bbox.x2 && y >= bbox.y && y <= bbox.y2;
1312 return i(bbox2, bbox1.x, bbox1.y)
1314 || i(bbox2, bbox1.x, bbox1.y2)
1316 || i(bbox1, bbox2.x, bbox2.y)
1318 || i(bbox1, bbox2.x, bbox2.y2)
1320 || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x)
1396 return {x: px, y: py};
1420 dots1.push({x: p.x, y: p.y, t: i / n1});
1424 dots2.push({x: p.x, y: p.y, t: i / n2});
1432 ci = abs(di1.x - di.x) < .001 ? "y" : "x",
1433 cj = abs(dj1.x - dj.x) < .001 ? "y" : "x",
1434 is = intersect(di.x, di.y, di1.x, di1.y, dj.x, dj.y, dj1.x, dj1.y);
1436 if (xy[is.x.toFixed(4)] == is.y.toFixed(4)) {
1439 xy[is.x.toFixed(4)] = is.y.toFixed(4);
1447 x: is.x,
1555 R.isPointInsidePath = function (path, x, y) { argument
1557 return R.isPointInsideBBox(bbox, x, y) &&
1558 interPathHelper(path, [["M", x, y], ["H", bbox.x2 + 10]], 1) % 2 == 1;
1592 return {x: 0, y: 0, width: 0, height: 0, x2: 0, y2: 0};
1595 var x = 0,
1603 x = p[1];
1605 X.push(x);
1608 var dim = curveDim(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
1609 X = X[concat](dim.min.x, dim.max.x);
1611 x = p[5];
1622 x: xmin,
1648 x = 0,
1654 x = pathArray[0][1];
1656 mx = x;
1659 res.push(["M", x, y]);
1673 r[6] = +(pa[6] - x).toFixed(3);
1684 r[j] = +(pa[j] - ((j % 2) ? x : y)).toFixed(3);
1690 mx = pa[1] + x;
1700 x = mx;
1704 x += +res[i][len - 1];
1710 x += +res[i][len - 2];
1730 x = 0,
1736 x = +pathArray[0][1];
1738 mx = x;
1741 res[0] = ["M", x, y];
1756 r[6] = +(pa[6] + x);
1763 r[1] = +pa[1] + x;
1766 var dots = [x, y][concat](pa.slice(1));
1768 dots[j] = +dots[j] + x;
1775 mx = +pa[1] + x;
1779 r[j] = +pa[j] + ((j % 2) ? x : y);
1783 dots = [x, y][concat](pa.slice(1));
1794 x = mx;
1798 x = r[1];
1807 x = r[r.length - 2];
1837 rotate = cacher(function (x, y, rad) { argument
1838 var X = x * math.cos(rad) - y * math.sin(rad),
1839 Y = x * math.sin(rad) + y * math.cos(rad);
1840 return {x: X, y: Y};
1844 x1 = xy.x;
1847 x2 = xy.x;
1851 x = (x1 - x2) / 2,
1853 var h = (x * x) / (rx * rx) + (y * y) / (ry * ry);
1862 … math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),
1864 cy = k * -ry * x / rx + (y1 + y2) / 2,
1914 … newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x;
1922 … x: pow(t1, 3) * p1x + pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + pow(t, 3) * p2x,
1933 x = [p1x, p2x],
1939 x.push(dot.x);
1944 x.push(dot.x);
1956 x.push(dot.x);
1961 x.push(dot.x);
1965 min: {x: mmin[apply](0, x), y: mmin[apply](0, y)},
1966 max: {x: mmax[apply](0, x), y: mmax[apply](0, y)}
1976 attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null}, property in AnonymousFunction19fc41e64b00.attrs
1977 attrs2 = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null}, property in AnonymousFunction19fc41e64b00.attrs2
1981 return ["C", d.x, d.y, d.x, d.y, d.x, d.y];
1990 path = ["C"][concat](a2c[apply](0, [d.x, d.y][concat](path.slice(1))));
1994 nx = d.x * 2 - d.bx; // And reflect the previous
1998 nx = d.x;
2005 d.qx = d.x * 2 - d.qx; // And make a reflection similar
2009 d.qx = d.x;
2012 path = ["C"][concat](q2c(d.x, d.y, d.qx, d.qy, path[1], path[2]));
2017 path = ["C"][concat](q2c(d.x, d.y, path[1], path[2], path[3], path[4]));
2020 path = ["C"][concat](l2c(d.x, d.y, path[1], path[2]));
2023 path = ["C"][concat](l2c(d.x, d.y, path[1], d.y));
2026 path = ["C"][concat](l2c(d.x, d.y, d.x, path[1]));
2029 path = ["C"][concat](l2c(d.x, d.y, d.X, d.Y));
2049 path2.splice(i, 0, ["M", a2.x, a2.y]);
2052 a1.x = path1[i][1];
2096 attrs.x = seg[seglen - 2];
2098 attrs.bx = toFloat(seg[seglen - 4]) || attrs.x;
2100 attrs2.bx = p2 && (toFloat(seg2[seg2len - 4]) || attrs2.x);
2102 attrs2.x = p2 && seg2[seg2len - 2];
2258 x1 = inver.x(0, 0);
2260 x2 = inver.x(t[1], t[2]);
2269 m.rotate(t[1], bb.x + bb.width / 2, bb.y + bb.height / 2);
2273 x2 = inver.x(t[2], t[3]);
2284 m.scale(t[1], t[tlen - 1], bb.x + bb.width / 2, bb.y + bb.height / 2);
2289 x2 = inver.x(t[3], t[4]);
2321 _.bbox.x += +dx;
2376 R._getContainer = function (x, y, w, h) { argument
2378 container = h == null && !R.is(x, "object") ? g.doc.getElementById(x) : x;
2399 x: x,
2486 x, y, z, res;
2492 for (x = 0; x < 3; x++) {
2496 res += m[x][z] * matrix[z][y];
2498 out[x][y] = res;
2517 x = me.a * me.d - me.b * me.c;
2518 …return new Matrix(me.d / x, -me.b / x, -me.c / x, me.a / x, (me.c * me.f - me.d * me.e) / x, (me.b…
2539 matrixproto.translate = function (x, y) { argument
2540 this.add(1, 0, 0, 1, x, y);
2553 matrixproto.scale = function (x, y, cx, cy) { argument
2554 y == null && (y = x);
2556 this.add(x, 0, 0, y, 0, 0);
2569 matrixproto.rotate = function (a, x, y) { argument
2571 x = x || 0;
2575 this.add(cos, sin, -sin, cos, x, y);
2576 this.add(1, 0, 0, 1, -x, -y);
2588 matrixproto.x = function (x, y) { argument
2589 return x * this.a + y * this.c + this.e;
2601 matrixproto.y = function (x, y) { argument
2602 return x * this.b + y * this.d + this.f;
2716 x: e.clientX + scrollX,
2725 return fn.call(element, e, pos.x, pos.y);
2744 return fn.call(element, e, pos.x, pos.y);
2764 x = e.clientX + scrollX,
2768 return fn.call(element, e, x, y);
2781 var x = e.clientX,
2795 x = touch.clientX;
2811 o = dragi.el.paper.getElementByPoint(x, y);
2815 x += scrollX;
2817 …g.move." + dragi.el.id, dragi.move_scope || dragi.el, x - dragi.el._drag.x, y - dragi.el._drag.y, …
3212 var x = e.clientX,
3223 x = touch.clientX;
3229 this._drag.x = x + scrollX;
3236 …eve("raphael.drag.start." + this.id, start_scope || move_scope || this, this._drag.x, this._drag.y…
3286 paperproto.circle = function (x, y, r) { argument
3287 var out = R._engine.circle(this, x || 0, y || 0, r || 0);
3312 paperproto.rect = function (x, y, w, h, r) { argument
3313 var out = R._engine.rect(this, x || 0, y || 0, w || 0, h || 0, r || 0);
3334 paperproto.ellipse = function (x, y, rx, ry) { argument
3335 var out = R._engine.ellipse(this, x || 0, y || 0, rx || 0, ry || 0);
3395 paperproto.image = function (src, x, y, w, h) { argument
3396 var out = R._engine.image(this, src || "about:blank", x || 0, y || 0, w || 0, h || 0);
3416 paperproto.text = function (x, y, text) { argument
3417 var out = R._engine.text(this, x || 0, y || 0, Str(text));
3520 paperproto.setViewBox = function (x, y, w, h, fit) { argument
3521 return R._engine.setViewBox.call(this, x, y, w, h, fit);
3553 x: left
3570 paperproto.getElementByPoint = function (x, y) { argument
3573 target = g.doc.elementFromPoint(x, y);
3577 sr.x = x - so.x;
3678 paperproto.getElementsByPoint = function (x, y) { argument
3681 if (el.isPointInside(x, y)) {
3688 return this.x + S + this.y;
3691 return this.x + S + this.y + S + this.width + " \xd7 " + this.height;
3705 elproto.isPointInside = function (x, y) { argument
3710 return R.isPointInsidePath(rp, x, y);
3833 var x, y, p, l, sp = "", subpaths = {}, point,
3838 x = +p[1];
3841 l = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
3844 … point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);
3845 … sp += ["C" + point.start.x, point.start.y, point.m.x, point.m.y, point.x, point.y];
3848 …sp = ["M" + point.x, point.y + "C" + point.n.x, point.n.y, point.end.x, point.end.y, p[5], p[6]].j…
3850 x = +p[5];
3855 … point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);
3856 return {x: point.x, y: point.y, alpha: point.alpha};
3860 x = +p[5];
3866 …point = istotal ? len : subpath ? subpaths : R.findDotsAtSegment(x, y, p[0], p[1], p[2], p[3], p[4…
3867 point.alpha && (point = {x: point.x, y: point.y, alpha: point.alpha});
4044 x = Q - q,
4045 X = pow(abs(x), 1 / 3) * (x < 0 ? -1 : 1),
4258 x, y;
4283 function solve(x, epsilon) { argument
4284 var t = solveCurveX(x, epsilon);
4287 function solveCurveX(x, epsilon) { argument
4289 for(t2 = x, i = 0; i < 8; i++) {
4290 x2 = sampleCurveX(t2) - x;
4302 t2 = x;
4311 if (abs(x2 - x) < epsilon) {
4314 if (x > x2) {
5003 var x = [],
5009 x.push(box.x);
5011 x2.push(box.x + box.width);
5014 x = mmin[apply](0, x);
5019 x: x,
5023 width: x2 - x,
5064 setproto.isPointInside = function (x, y) { argument
5067 if (el.isPointInside(x, y)) {
5117 return {l: "L", c: "C", x: "z", t: "m", r: "l", v: "c"}[command] || "M";
5194 paperproto.print = function (x, y, string, font, size, origin, letter_spacing, line_spacing) { argument
5224 … ["t", shift * scale, shifty * scale, "s", scale, scale, top, height, "t", (x - top) / scale, (y -…