Lines Matching +defs:b +defs:t

45         numsort = function (a, b) {
46             return a - b;
211      * Note: I assume most of the time you don’t need to worry about z-index, but it’s nice to have this feature “just in case”.
250      | eve.on("click", function (a, b, c) {
251      |     console.log(a, b, c); // 1, 2, [event object]
473     diff = function (a, b, A, B) {
477                 res[i] = diff(a[i], b, A[i], B);
481         var dif = (A - a) / (B - b);
483             return a + dif * (bb - b);
495         a.b += a.dur * ds;
527         a.pdif = a.get() - a.b;
534         a.b = a.get() - a.pdif;
556                 b = a.get(),
559             a.s = (b - a.b) / (a.dur / a.spd);
582      - b (number) start _master_ number (start time in general case)
592      o         b (number) start _master_ number,
608     mina = function (a, A, b, B, get, set, easing) {
613             b: b,
615             dur: B - b,
715             t = X + Y + .5;
716         return (1 - t) * 3 * t * t + t * t * t;
1350  o     b (number) blue,
1352  o     error (boolean) true if string can't be parsed
1357         return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: rgbtoString};
1360         return {r: -1, g: -1, b: -1, hex: "none", toString: rgbtoString};
1364         return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: rgbtoString};
1371         t,
1381             blue = toInt((t = rgb[3].charAt(3)) + t, 16);
1382             green = toInt((t = rgb[3].charAt(2)) + t, 16);
1383             red = toInt((t = rgb[3].charAt(1)) + t, 16);
1426         rgb = {r: red, g: green, b: blue, toString: rgbtoString};
1431     return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: rgbtoString};
1440  - b (number) value or brightness
1443 Snap.hsb = cacher(function (h, s, b) {
1444     return Snap.hsb2rgb(h, s, b).hex;
1466  - b (number) blue
1469 Snap.rgb = cacher(function (r, g, b, o) {
1472         return "rgba(" + [round(r), round(g), round(b), +o.toFixed(2)] + ")";
1474     return "#" + (16777216 | b | (g << 8) | (r << 16)).toString(16).slice(1);
1491     return "hsb(" + [this.h, this.s, this.b] + ")";
1499             "rgba(" + [this.r, this.g, this.b, this.opacity] + ")";
1501 prepareRGB = function (r, g, b) {
1502     if (g == null && is(r, "object") && "r" in r && "g" in r && "b" in r) {
1503         b = r.b;
1511         b = clr.b;
1513     if (r > 1 || g > 1 || b > 1) {
1516         b /= 255;
1519     return [r, g, b];
1521 packageRGB = function (r, g, b, o) {
1524     b = math.round(b * 255);
1528         b: b,
1530         hex: Snap.rgb(r, g, b),
1546  o     b (number) blue,
1548  o     error (boolean) `true` if string can't be parsed,
1557     if (is(clr, "object") && "h" in clr && "s" in clr && "b" in clr) {
1561         clr.b = rgb.b;
1568         clr.b = rgb.b;
1575         if (is(clr, "object") && "r" in clr && "g" in clr && "b" in clr && !("error" in clr)) {
1581             clr.v = rgb.b;
1584             clr.r = clr.g = clr.b = clr.h = clr.s = clr.v = clr.l = -1;
1603  o     b (number) blue,
1608     if (is(h, "object") && "h" in h && "s" in h && "b" in h) {
1609         v = h.b;
1639  o     b (number) blue,
1674  - b (number) blue
1679  o     b (number) brightness
1682 Snap.rgb2hsb = function (r, g, b) {
1683     b = prepareRGB(r, g, b);
1684     r = b[0];
1685     g = b[1];
1686     b = b[2];
1689     V = mmax(r, g, b);
1690     C = V - mmin(r, g, b);
1692          V == r ? (g - b) / C :
1693          V == g ? (b - r) / C + 2 :
1698     return {h: H, s: S, b: V, toString: hsbtoString};
1707  - b (number) blue
1715 Snap.rgb2hsl = function (r, g, b) {
1716     b = prepareRGB(r, g, b);
1717     r = b[0];
1718     g = b[1];
1719     b = b[2];
1722     M = mmax(r, g, b);
1723     m = mmin(r, g, b);
1726          M == r ? (g - b) / C :
1727          M == g ? (b - r) / C + 2 :
1757     var paramCounts = {a: 7, c: 6, o: 2, h: 1, l: 2, m: 2, r: 4, q: 4, s: 4, t: 2, v: 1, u: 3, z: 0},
1763         Str(pathString).replace(pathCommand, function (a, b, c) {
1765                 name = b.toLowerCase();
1766             c.replace(pathValues, function (a, b) {
1767                 b && params.push(+b);
1770                 data.push([b].concat(params.splice(0, 2)));
1772                 b = b == "m" ? "l" : "L";
1775                 data.push([b, params[0]]);
1778                 data.push([b].concat(params));
1780                 data.push([b].concat(params.splice(0, paramCounts[name])));
1805     var paramCounts = {r: 3, s: 4, t: 2, m: 6},
1811         Str(TString).replace(tCommand, function (a, b, c) {
1813                 name = b.toLowerCase();
1814             c.replace(pathValues, function (a, b) {
1815                 b && params.push(+b);
1817             data.push([b].concat(params));
1858             var t = tdata[i],
1859                 tlen = t.length,
1860                 command = Str(t[0]).toLowerCase(),
1861                 absolute = t[0] != command,
1868             if (command == "t" && tlen == 2){
1869                 m.translate(t[1], 0);
1870             } else if (command == "t" && tlen == 3) {
1874                     x2 = inver.x(t[1], t[2]);
1875                     y2 = inver.y(t[1], t[2]);
1878                     m.translate(t[1], t[2]);
1883                     m.rotate(t[1], bb.x + bb.width / 2, bb.y + bb.height / 2);
1886                         x2 = inver.x(t[2], t[3]);
1887                         y2 = inver.y(t[2], t[3]);
1888                         m.rotate(t[1], x2, y2);
1890                         m.rotate(t[1], t[2], t[3]);
1896                     m.scale(t[1], t[tlen - 1], bb.x + bb.width / 2, bb.y + bb.height / 2);
1899                         x2 = inver.x(t[2], t[3]);
1900                         y2 = inver.y(t[2], t[3]);
1901                         m.scale(t[1], t[1], x2, y2);
1903                         m.scale(t[1], t[1], t[2], t[3]);
1907                         x2 = inver.x(t[3], t[4]);
1908                         y2 = inver.y(t[3], t[4]);
1909                         m.scale(t[1], t[2], x2, y2);
1911                         m.scale(t[1], t[2], t[3], t[4]);
1915                 m.add(t[1], t[2], t[3], t[4], t[5], t[6]);
1924     function (a, b) {
1926             bup = b && b.parentNode;
1933     function (a, b) {
1934         if (b) {
1935             while (b) {
1936                 b = b.parentNode;
1937                 if (b == a) {
2728             // Firefox doesn’t give you bbox of hidden element
3257 // SIERRA Element.marker(): I suggest the method should accept default reference point values.  Perhaps centered with (refX = width/2) and (refY = height/2)? Also, couldn't it assume the element's current _width_ and _height_? And please specify what _x_ and _y_ mean: offsets? If so, from where?  Couldn't they also be assigned default values?
3492      * Adds or retrieves given value associated with given key. (Don’t confuse
3646     function Matrix(a, b, c, d, e, f) {
3647         if (b == null && objectToString.call(a) == "[object SVGMatrix]") {
3649             this.b = a.b;
3658             this.b = +b;
3665             this.b = 0;
3679          - b (number)
3687         matrixproto.add = function (a, b, c, d, e, f) {
3689                 m = [[this.a, this.c, this.e], [this.b, this.d, this.f], [0, 0, 1]],
3690                 matrix = [[a, c, e], [b, d, f], [0, 0, 1]],
3694                 matrix = [[a.a, a.c, a.e], [a.b, a.d, a.f], [0, 0, 1]];
3707             this.b = out[1][0];
3723                 x = me.a * me.d - me.b * me.c;
3724             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 * me.e - me.a * me.f) / x);
3734             return new Matrix(this.a, this.b, this.c, this.d, this.e, this.f);
3805             return x * this.b + y * this.d + this.f;
3832             return this.a * this.d - this.b * this.c;
3855             var row = [[this.a, this.c], [this.b, this.d]];
3900                 return  (s.dx || s.dy ? "t" + [+s.dx.toFixed(4), +s.dy.toFixed(4)] : E) + 
3924      - b (number)
3933     Snap.matrix = function (a, b, c, d, e, f) {
3934         return new Matrix(a, b, c, d, e, f);
4364         rgBadSpace = /[\t\r\n\f]/g,
4560     eve.on("snap.util.equal", function (name, b) {
4563             bplus = Str(b).match(reAddon);
5458     function findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
5459         var t1 = 1 - t,
5462             t2 = t * t,
5463             t3 = t2 * t,
5464             x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x,
5465             y = t13 * p1y + t12 * 3 * t * c1y + t1 * 3 * t * t * c2y + t3 * p2y,
5466             mx = p1x + 2 * t * (c1x - p1x) + t2 * (c2x - 2 * c1x + p1x),
5467             my = p1y + 2 * t * (c1y - p1y) + t2 * (c2y - 2 * c1y + p1y),
5468             nx = c1x + 2 * t * (c2x - c1x) + t2 * (p2x - 2 * c2x + c1x),
5469             ny = c1y + 2 * t * (c2y - c1y) + t2 * (p2y - 2 * c2y + c1y),
5470             ax = t1 * p1x + t * c1x,
5471             ay = t1 * p1y + t * c1y,
5472             cx = t1 * c2x + t * p2x,
5473             cy = t1 * c2y + t * p2y,
5520     function base3(t, p1, p2, p3, p4) {
5522             t2 = t * t1 + 6 * p1 - 12 * p2 + 6 * p3;
5523         return t * t2 - 3 * p1 + 3 * p2;
5548         var t = 1,
5549             step = t / 2,
5550             t2 = t - step,
5617             dots1.push({x: p.x, y: p.y, t: i / n1});
5621             dots2.push({x: p.x, y: p.y, t: i / n2});
5637                     var t1 = di.t + abs((is[ci] - di[ci]) / (di1[ci] - di[ci])) * (di1.t - di.t),
5638                         t2 = dj.t + abs((is[cj] - dj[cj]) / (dj1[cj] - dj[cj])) * (dj1.t - dj.t);
6127             t = math.tan(df / 4),
6128             hx = 4 / 3 * rx * t,
6129             hy = 4 / 3 * ry * t,
6147     function findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
6148         var t1 = 1 - t;
6150             x: pow(t1, 3) * p1x + pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + pow(t, 3) * p2x,
6151             y: pow(t1, 3) * p1y + pow(t1, 2) * 3 * t * c1y + t1 * 3 * t * t * c2y + pow(t, 3) * p2y
6162             a, b, c, t, t1, t2, b2ac, sqrtb2ac;
6165                 b = 6 * x0 - 12 * x1 + 6 * x2;
6169                 b = 6 * y0 - 12 * y1 + 6 * y2;
6174                 if (abs(b) < 1e-12) {
6177                 t = -c / b;
6178                 if (0 < t && t < 1) {
6179                     tvalues.push(t);
6183             b2ac = b * b - 4 * c * a;
6188             t1 = (-b + sqrtb2ac) / (2 * a);
6192             t2 = (-b - sqrtb2ac) / (2 * a);
6202             t = tvalues[j];
6203             mt = 1 - t;
6204             bounds[0][j] = (mt * mt * mt * x0) + (3 * mt * mt * t * x1) + (3 * mt * t * t * x2) + (t * t * t * x3);
6205             bounds[1][j] = (mt * mt * mt * y0) + (3 * mt * mt * t * y1) + (3 * mt * t * t * y2) + (t * t * t * y3);
6523      * Finds dot coordinates on the given cubic beziér curve at the given t
6532      - t (number) position on the curve (0..1)
6600             b = box(x - r / 2, y - r / 2, r, r),
6617                 if (isPointInsideBBox(b, xy.x, xy.y)) {
6625                 b = box(x - r / 2, y - r / 2, r, r)
6669      o         t1: (number) t value for segment of path1,
6670      o         t2: (number) t value for segment of path2,
6688      * Note: fill mode doesn’t affect the result of this method.
6885                     this.b = begin;
6887                     begin = this.b;
6931     setproto.bind = function (attr, a, b) {
6936             var aname = b || attr;
7099             case "t": return [l, 0, 0];
7133                     from = [["m", t1.a, t1.b, t1.c, t1.d, t1.e, t1.f]];
7134                     to = [["m", t2.a, t2.b, t2.c, t2.d, t2.e, t2.f]];
7165         var k = 0, i, ii, j, jj, out, a, b = [];
7173             b[i] = out;
7175         return Function("val", "return Snap.path.toString.call([" + b + "])");
7195     Element.prototype.equal = function (name, b) {
7196         return eve("snap.util.equal", this, name, b).firstDefined();
7198     eve.on("snap.util.equal", function (name, b) {
7201         if (isNumeric(a) && isNumeric(b)) {
7204                 to: parseFloat(b),
7210             B = Snap.color(b);
7212                 from: [A.r, A.g, A.b, A.opacity],
7213                 to: [B.r, B.g, B.b, B.opacity],
7219             B = b.split(" ").map(Number);
7227             if (b instanceof Snap.Matrix) {
7228                 b = b.toTransformString();
7230             if (!Snap._.rgTransform.test(b)) {
7231                 b = Snap._.svgTransform2string(b);
7233             return equaliseTransform(a, b, function () {
7238             A = Snap.path.toCubic(a, b);
7247             B = Str(b).split(Snap._.separator);
7255             bUnit = Str(b).match(reUnit);
7259                 to: parseFloat(b),
7265                 to: this.asPX(name, b),
7693                     transform: origTransform + (origTransform ? "T" : "t") + [dx, dy]
7931         return Snap.format('<feColorMatrix type="matrix" values="{a} {b} {c} 0 0 {d} {e} {f} 0 0 {g} {b} {h} 0 0 0 0 0 1 0"/>', {
7933             b: 0.7152 - 0.7152 * (1 - amount),
7958         return Snap.format('<feColorMatrix type="matrix" values="{a} {b} {c} 0 0 {d} {e} {f} 0 0 {g} {h} {i} 0 0 0 0 0 1 0"/>', {
7960             b: 0.769 - 0.769 * (1 - amount),
8122             case "t":
8126             case "b":