--- /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-debug.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"]});