Lines Matching +defs:f +defs:t

87                 f = false,
180                         out = out.concat(item.f || []);
194      | eve.on("*.under.*", f);
195      | eve("mouse.under.floor"); // triggers f
201      - f (function) event handler function
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”.
213     eve.on = function (name, f) {
215         if (typeof f != "function") {
228                 e.f = e.f || [];
229                 for (i = 0, ii = e.f.length; i < ii; i++) if (e.f[i] == f) {
233                 !exist && e.f.push(f);
238                 f.zIndex = +zIndex;
243      * eve.f
249      | el.onclick = eve.f("click", 1, 2);
258     eve.f = function (event) {
315      - f (function) event handler function
323     eve.off = eve.unbind = function (name, f) {
331                 eve.off(names[i], f);
360                 if (f) {
361                     if (e.f) {
362                         for (j = 0, jj = e.f.length; j < jj; j++) if (e.f[j] == f) {
363                             e.f.splice(j, 1);
366                         !e.f.length && delete e.f;
368                     for (key in e.n) if (e.n[has](key) && e.n[key].f) {
369                         var funcs = e.n[key].f;
370                         for (j = 0, jj = funcs.length; j < jj; j++) if (funcs[j] == f) {
374                         !funcs.length && delete e.n[key].f;
377                     delete e.f;
378                     for (key in e.n) if (e.n[has](key) && e.n[key].f) {
379                         delete e.n[key].f;
391      | eve.once("login", f);
392      | eve("login"); // triggers f
399      - f (function) event handler function
403     eve.once = function (name, f) {
406             return f.apply(this, arguments);
715             t = X + Y + .5;
716         return (1 - t) * 3 * t * t + t * t * t;
873     colourRegExp = /^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgba?\(\s*([\d\.]+%?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+%?)?)\s*\)|hsba?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?%?)\s*\)|hsla?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?%?)\s*\))\s*$/i,
1035 function cacher(f, scope, postprocessor) {
1047         cache[args] = f.apply(scope, arg);
1352  o     error (boolean) true if string can't be parsed
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);
1548  o     error (boolean) `true` if string can't be parsed,
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},
1805     var paramCounts = {r: 3, s: 4, t: 2, m: 6},
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]);
1998     function set(nam, f) {
2000             out[nam] = f(el.attr(nam) || 0);
2002             out = f(value == null ? el.attr(nam) || 0 : value);
2229     var f = glob.doc.createDocumentFragment(),
2241             f = svg;
2244                 f.appendChild(svg.firstChild);
2248     return new Fragment(f);
2264         f = glob.doc.createDocumentFragment();
2268             f.appendChild(item.node);
2271             f.appendChild(item);
2274             f.appendChild(Snap.parse(item).node);
2277     return new Fragment(f);
2576         var f = Snap.parse(req.responseText);
2577         scope ? callback.call(scope, f) : callback(f);
2638  - f (function) your plugin body
2640 Snap.plugin = function (f) {
2641     f(Snap, Element, Paper, glob, Fragment);
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?
3301     function slice(from, to, f) {
3307             return f ? f(res) : res;
3449         var fkeys = [], tkeys = [], keys = {}, from, to, f, eq,
3456                 f = eq.f;
3462             keys[key] = slice(fkeys.length, fkeys.length + len, f);
3492      * Adds or retrieves given value associated with given key. (Don’t confuse
3646     function Matrix(a, b, c, d, e, f) {
3653             this.f = a.f;
3662             this.f = +f;
3669             this.f = 0;
3683          - f (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]];
3711             this.f = out[1][2];
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;
3814             return [this.e.toFixed(4), this.f.toFixed(4)];
3852             out.dy = this.f;
3900                 return  (s.dx || s.dy ? "t" + [+s.dx.toFixed(4), +s.dy.toFixed(4)] : E) + 
3928      - f (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,
4573                     f: getUnit(aUnit)
4580                     f: getNumber
4675         return function (src, f) {
4680                 f.call(img);
5262                 f = doc.createDocumentFragment(),
5266             f.appendChild(d);
5270             f.removeChild(f.firstChild);
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;
6177                 t = -c / b;
6178                 if (0 < t && t < 1) {
6179                     tvalues.push(t);
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)
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.
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]];
7147             f: getPath(from)
7205                 f: getNumber
7214                 f: getColour
7223                 f: getViewBox
7242                 f: getPath(A[0])
7251                 f: function (val) { return val; }
7260                 f: getUnit(aUnit)
7266                 f: getNumber
7318             f = function (e) {
7339             obj.addEventListener(type, f, false);
7342         obj.addEventListener(realName, f, false);
7346                 obj.removeEventListener(type, f, false);
7349             obj.removeEventListener(realName, f, false);
7599                         f: fn,
7605                             this.events[i].f.call(this);
7616                                (events[l].f == fn || !fn)) {
7693                     transform: origTransform + (origTransform ? "T" : "t") + [dx, dy]
7725      - f (function) handler for event, first argument would be the element you are dragging over
7727     // elproto.onDragOver = function (f) {
7728     //     f ? eve.on("snap.drag.over." + this.id, f) : eve.unbind("snap.drag.over." + this.id);
7779      | var f = paper.filter('<feGaussianBlur stdDeviation="2"/>'),
7781      |         filter: f
7789         var f = Snap.parse(Str(filstr)),
7798         filter.appendChild(f.node);
7838      | var f = paper.filter(Snap.filter.blur(5, 10)),
7840      |         filter: f
7877      | var f = paper.filter(Snap.filter.shadow(0, 2, 3)),
7879      |         filter: f
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"/>', {
7937             f: 0.0722 - 0.0722 * (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"/>', {
7964             f: 0.168 - 0.168 * (1 - amount),
8122             case "t":