diff -r d334a616c023 -r e16a97fb364a src/cm/media/js/lib/yui/yui3-3.15.0/build/transition-timer/transition-timer.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cm/media/js/lib/yui/yui3-3.15.0/build/transition-timer/transition-timer.js Mon Mar 10 15:19:48 2014 +0100 @@ -0,0 +1,334 @@ +YUI.add('transition-timer', function (Y, NAME) { + +/** +* Provides the base Transition class, for animating numeric properties. +* +* @module transition +* @submodule transition-timer +*/ + + +var Transition = Y.Transition; + +Y.mix(Transition.prototype, { + _start: function() { + if (Transition.useNative) { + this._runNative(); + } else { + this._runTimer(); + } + }, + + _runTimer: function() { + var anim = this; + anim._initAttrs(); + + Transition._running[Y.stamp(anim)] = anim; + anim._startTime = new Date(); + Transition._startTimer(); + }, + + _endTimer: function() { + var anim = this; + delete Transition._running[Y.stamp(anim)]; + anim._startTime = null; + }, + + _runFrame: function() { + var t = new Date() - this._startTime; + this._runAttrs(t); + }, + + _runAttrs: function(time) { + var anim = this, + node = anim._node, + config = anim._config, + uid = Y.stamp(node), + attrs = Transition._nodeAttrs[uid], + customAttr = Transition.behaviors, + done = false, + allDone = false, + data, + name, + attribute, + setter, + elapsed, + delay, + d, + t, + i; + + for (name in attrs) { + if ((attribute = attrs[name]) && attribute.transition === anim) { + d = attribute.duration; + delay = attribute.delay; + elapsed = (time - delay) / 1000; + t = time; + data = { + type: 'propertyEnd', + propertyName: name, + config: config, + elapsedTime: elapsed + }; + + setter = (i in customAttr && 'set' in customAttr[i]) ? + customAttr[i].set : Transition.DEFAULT_SETTER; + + done = (t >= d); + + if (t > d) { + t = d; + } + + if (!delay || time >= delay) { + setter(anim, name, attribute.from, attribute.to, t - delay, d - delay, + attribute.easing, attribute.unit); + + if (done) { + delete attrs[name]; + anim._count--; + + if (config[name] && config[name].on && config[name].on.end) { + config[name].on.end.call(Y.one(node), data); + } + + //node.fire('transition:propertyEnd', data); + + if (!allDone && anim._count <= 0) { + allDone = true; + anim._end(elapsed); + anim._endTimer(); + } + } + } + + } + } + }, + + _initAttrs: function() { + var anim = this, + customAttr = Transition.behaviors, + uid = Y.stamp(anim._node), + attrs = Transition._nodeAttrs[uid], + attribute, + duration, + delay, + easing, + val, + name, + mTo, + mFrom, + unit, begin, end; + + for (name in attrs) { + if ((attribute = attrs[name]) && attribute.transition === anim) { + duration = attribute.duration * 1000; + delay = attribute.delay * 1000; + easing = attribute.easing; + val = attribute.value; + + // only allow supported properties + if (name in anim._node.style || name in Y.DOM.CUSTOM_STYLES) { + begin = (name in customAttr && 'get' in customAttr[name]) ? + customAttr[name].get(anim, name) : Transition.DEFAULT_GETTER(anim, name); + + mFrom = Transition.RE_UNITS.exec(begin); + 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 (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]; + } + } + + attribute.from = Number(begin); + attribute.to = Number(end); + attribute.unit = unit; + attribute.easing = easing; + attribute.duration = duration + delay; + attribute.delay = delay; + } else { + delete attrs[name]; + anim._count--; + } + } + } + }, + + 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, 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 (node) { + if (att in node.style || att in Y.DOM.CUSTOM_STYLES) { + unit = unit || ''; + Y.DOM.setStyle(node, att, val + unit); + } + } else { + anim._end(); + } + }, + + /* + * 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.style || att in Y.DOM.CUSTOM_STYLES) { + val = Y.DOM.getComputedStyle(node, 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"]});