transition.js revision 89834780bfb209028a4e6758c8f139b626ac4324
906N/AYUI.add('transition', function(Y) {
906N/A
906N/A/**
906N/A* The Transition Utility provides an API for creating advanced transitions.
906N/A* @module node
906N/A*/
906N/A
906N/A/**
906N/A* Provides the base Transition class, for animating numeric properties.
906N/A*
906N/A* @module node
906N/A* @submodule transition
906N/A*/
906N/A
906N/A/**
906N/A * A class for constructing animation instances.
906N/A * @class Transition
906N/A * @for Transition
906N/A * @constructor
906N/A */
906N/A
1389N/Avar START = 'transition:start',
906N/A END = 'transition:end',
906N/A PROPERTY_END = 'transition:propertyEnd',
906N/A Transition = Y.Transition;
906N/A
906N/AY.mix(Transition.prototype, {
1799N/A _start: function() {
1799N/A if (Transition.useNative) {
1799N/A this._runNative();
906N/A } else {
906N/A this._runTimer();
1799N/A }
1799N/A },
1799N/A
906N/A _runTimer: function() {
906N/A var anim = this;
1389N/A anim._initAttrs();
1389N/A
906N/A Transition._running[Y.stamp(anim)] = anim;
906N/A anim._startTime = new Date();
906N/A Transition._startTimer();
906N/A },
906N/A
1389N/A _end: function(finish) {
906N/A var duration = this._duration * 1000;
1799N/A if (finish) { // jump to last frame
1799N/A this._runAttrs(duration, duration);
1799N/A }
1799N/A
1799N/A delete Transition._running[Y.stamp(this)];
906N/A this._running = false;
906N/A this._startTime = null;
906N/A },
906N/A
1389N/A _runFrame: function() {
1389N/A var t = new Date() - this._startTime;
1389N/A this._runAttrs(t);
906N/A },
1389N/A
906N/A _runAttrs: function(time) {
906N/A var anim = this,
1389N/A node = anim._node,
1799N/A attr = Transition._runtimeAttrs[Y.stamp(node)],
906N/A customAttr = Transition.behaviors,
906N/A done = false,
906N/A allDone = false,
1799N/A attribute,
906N/A setter,
906N/A elapsed,
906N/A eventElapsed,
906N/A delay,
906N/A d,
906N/A t,
906N/A i;
906N/A
906N/A for (i in attr) {
906N/A if (attr[i].to) {
906N/A attribute = attr[i];
d = attribute.duration;
delay = attribute.delay;
elapsed = time / 1000;
t = time;
setter = (i in customAttr && 'set' in customAttr[i]) ?
customAttr[i].set : Transition.DEFAULT_SETTER;
done = (t >= d);
if (t > d) {
t = d;
}
if (!anim._skip[i] && (!delay || time >= delay)) {
setter(anim, i, attribute.from, attribute.to, t - delay, d - delay,
attribute.easing, attribute.unit);
if (done) {
anim._skip[i] = true;
anim._count--;
if (!allDone && anim._count <= 0) {
allDone = true;
anim._end();
if (anim._callback) {
anim._callback.call(anim._node, {
elapsedTime: (time - delay) / 1000
});
anim._callback = null;
}
}
}
}
}
}
},
_initAttrs: function() {
var from = {},
to = {},
easing = this._easing,
attr = {},
customAttr = Transition.behaviors,
attrs = this._attrs,
yuid = Y.stamp(this._node),
runtimeAttrs = Transition._runtimeAttrs[yuid],
duration,
delay,
val,
name,
unit, begin, end;
if (!runtimeAttrs) {
runtimeAttrs = Transition._runtimeAttrs[yuid] = {};
}
for (name in attrs) {
if (attrs.hasOwnProperty(name)) {
val = attrs[name];
duration = this._duration * 1000;
delay = this._delay * 1000;
if (typeof val.value !== 'undefined') {
duration = (('duration' in val) ? val.duration : this._duration) * 1000;
delay = (('delay' in val) ? val.delay : this._delay) * 1000;
easing = val.easing || easing;
val = val.value;
}
duration = duration || 1; // default to 1ms for 0 duration
duration += delay;
if (typeof val === 'function') {
val = val.call(this._node, this._node);
}
begin = (name in customAttr && 'get' in customAttr[name]) ?
customAttr[name].get(this, name) : Transition.DEFAULT_GETTER(this, name);
var mFrom = Transition.RE_UNITS.exec(begin);
var mTo = Transition.RE_UNITS.exec(val);
begin = mFrom ? mFrom[1] : begin;
end = mTo ? mTo[1] : val;
unit = mTo ? mTo[2] : mFrom ? mFrom[2] : ''; // one might be zero TODO: mixed units
if (!unit && Transition.RE_DEFAULT_UNIT.test(name)) {
unit = Transition.DEFAULT_UNIT;
}
if (!begin || !end) {
return;
}
if (typeof easing === 'string') {
if (easing.indexOf('cubic-bezier') > -1) {
easing = easing.substring(13, easing.length - 1).split(',');
} else if (Transition.easings[easing]) {
easing = Transition.easings[easing];
}
}
runtimeAttrs[name] = {
from: begin,
to: end,
unit: unit,
duration: duration,
delay: delay,
easing: easing
};
if (duration > this._totalDuration) {
this._totalDuration = duration;
}
this._count++;
}
}
this._skip = {};
},
destroy: function() {
this.detachAll();
this._node = null;
}
}, true);
Y.mix(Y.Transition, {
_runtimeAttrs: {},
/**
* Regex of properties that should use the default unit.
*
* @property RE_DEFAULT_UNIT
* @static
*/
RE_DEFAULT_UNIT: /^width|height|top|right|bottom|left|margin.*|padding.*|border.*$/i,
/**
* The default unit to use with properties that pass the RE_DEFAULT_UNIT test.
*
* @property DEFAULT_UNIT
* @static
*/
DEFAULT_UNIT: 'px',
/**
* Time in milliseconds passed to setInterval for frame processing
*
* @property intervalTime
* @default 20
* @static
*/
intervalTime: 20,
/**
* Bucket for custom getters and setters
*
* @property behaviors
* @static
*/
behaviors: {
left: {
get: function(anim, attr) {
return Y.DOM._getAttrOffset(anim._node._node, attr);
}
}
},
/**
* The default setter to use when setting object properties.
*
* @property DEFAULT_SETTER
* @static
*/
DEFAULT_SETTER: function(anim, att, from, to, elapsed, duration, fn, unit) {
from = Number(from);
to = Number(to);
var node = anim._node,
val = Transition.cubicBezier(fn, elapsed / duration);
val = from + val[0] * (to - from);
if (att in node._node.style || att in Y.DOM.CUSTOM_STYLES) {
unit = unit || '';
node.setStyle(att, val + unit);
} else if (node._node.attributes[att]) {
node.setAttribute(att, val);
} else {
node.set(att, val);
}
},
/**
* The default getter to use when getting object properties.
*
* @property DEFAULT_GETTER
* @static
*/
DEFAULT_GETTER: function(anim, att) {
var node = anim._node,
val = '';
if (att in node._node.style || att in Y.DOM.CUSTOM_STYLES) {
val = node.getComputedStyle(att);
} else if (node._node.attributes[att]) {
val = node.getAttribute(att);
} else {
val = node.get(att);
}
return val;
},
_startTimer: function() {
if (!Transition._timer) {
Transition._timer = setInterval(Transition._runFrame, Transition.intervalTime);
}
},
_stopTimer: function() {
clearInterval(Transition._timer);
Transition._timer = null;
},
/**
* Called per Interval to handle each animation frame.
* @method _runFrame
* @private
* @static
*/
_runFrame: function() {
var done = true,
anim;
for (anim in Transition._running) {
if (Transition._running[anim]._runFrame) {
done = false;
Transition._running[anim]._runFrame();
}
}
if (done) {
Transition._stopTimer();
}
},
cubicBezier: function(p, t) {
var x0 = 0,
y0 = 0,
x1 = p[0],
y1 = p[1],
x2 = p[2],
y2 = p[3],
x3 = 1,
y3 = 0,
A = x3 - 3 * x2 + 3 * x1 - x0,
B = 3 * x2 - 6 * x1 + 3 * x0,
C = 3 * x1 - 3 * x0,
D = x0,
E = y3 - 3 * y2 + 3 * y1 - y0,
F = 3 * y2 - 6 * y1 + 3 * y0,
G = 3 * y1 - 3 * y0,
H = y0,
x = (((A*t) + B)*t + C)*t + D,
y = (((E*t) + F)*t + G)*t + H;
return [x, y];
},
easings: {
ease: [0.25, 0, 1, 0.25],
linear: [0, 0, 1, 1],
'ease-in': [0.42, 0, 1, 1],
'ease-out': [0, 0, 0.58, 1],
'ease-in-out': [0.42, 0, 0.58, 1]
},
_running: {},
_timer: null,
RE_UNITS: /^(-?\d*\.?\d*){1}(em|ex|px|in|cm|mm|pt|pc|%)*$/
}, true);
Transition.behaviors.top = Transition.behaviors.bottom = Transition.behaviors.right = Transition.behaviors.left;
Y.Transition = Transition;
}, '@VERSION@' ,{requires:['transition-native', 'node-style']});