diff -r 322d0feea350 -r 89ef5ed3c48b src/cm/media/js/lib/yui/yui_3.10.3/build/scrollview-scrollbars/scrollview-scrollbars-debug.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.10.3/build/scrollview-scrollbars/scrollview-scrollbars-debug.js	Tue Jul 16 14:29:46 2013 +0200
@@ -0,0 +1,570 @@
+/*
+YUI 3.10.3 (build 2fb5187)
+Copyright 2013 Yahoo! Inc. All rights reserved.
+Licensed under the BSD License.
+http://yuilibrary.com/license/
+*/
+
+YUI.add('scrollview-scrollbars', function (Y, NAME) {
+
+/**
+ * Provides a plugin, which adds support for a scroll indicator to ScrollView instances
+ *
+ * @module scrollview
+ * @submodule scrollview-scrollbars
+ */
+
+var getClassName = Y.ClassNameManager.getClassName,
+    _classNames,
+
+    Transition = Y.Transition,
+    NATIVE_TRANSITIONS = Transition.useNative,
+    SCROLLBAR = 'scrollbar',
+    SCROLLVIEW = 'scrollview',
+
+    VERTICAL_NODE = "verticalNode",
+    HORIZONTAL_NODE = "horizontalNode",
+
+    CHILD_CACHE = "childCache",
+
+    TOP = "top",
+    LEFT = "left",
+    WIDTH = "width",
+    HEIGHT = "height",
+
+    HORIZ_CACHE = "_sbh",
+    VERT_CACHE = "_sbv",
+
+    TRANSITION_PROPERTY = Y.ScrollView._TRANSITION.PROPERTY,
+    TRANSFORM = "transform",
+
+    TRANSLATE_X = "translateX(",
+    TRANSLATE_Y = "translateY(",
+
+    SCALE_X = "scaleX(",
+    SCALE_Y = "scaleY(",
+    
+    SCROLL_X = "scrollX",
+    SCROLL_Y = "scrollY",
+
+    PX = "px",
+    CLOSE = ")",
+    PX_CLOSE = PX + CLOSE;
+
+/**
+ * ScrollView plugin that adds scroll indicators to ScrollView instances
+ *
+ * @class ScrollViewScrollbars
+ * @namespace Plugin
+ * @extends Plugin.Base
+ * @constructor
+ */
+function ScrollbarsPlugin() {
+    ScrollbarsPlugin.superclass.constructor.apply(this, arguments);
+}
+
+ScrollbarsPlugin.CLASS_NAMES = {
+    showing: getClassName(SCROLLVIEW, SCROLLBAR, 'showing'),
+    scrollbar: getClassName(SCROLLVIEW, SCROLLBAR),
+    scrollbarV: getClassName(SCROLLVIEW, SCROLLBAR, 'vert'),
+    scrollbarH: getClassName(SCROLLVIEW, SCROLLBAR, 'horiz'),
+    scrollbarVB: getClassName(SCROLLVIEW, SCROLLBAR, 'vert', 'basic'),
+    scrollbarHB: getClassName(SCROLLVIEW, SCROLLBAR, 'horiz', 'basic'),
+    child: getClassName(SCROLLVIEW, 'child'),
+    first: getClassName(SCROLLVIEW, 'first'),
+    middle: getClassName(SCROLLVIEW, 'middle'),
+    last: getClassName(SCROLLVIEW, 'last')
+};
+
+_classNames = ScrollbarsPlugin.CLASS_NAMES;
+
+/**
+ * The identity of the plugin
+ *
+ * @property NAME
+ * @type String
+ * @default 'pluginScrollViewScrollbars'
+ * @static
+ */
+ScrollbarsPlugin.NAME = 'pluginScrollViewScrollbars';
+    
+/**
+ * The namespace on which the plugin will reside.
+ *
+ * @property NS
+ * @type String
+ * @default 'scrollbars'
+ * @static
+ */
+ScrollbarsPlugin.NS = 'scrollbars';
+
+/**
+ * HTML template for the scrollbar
+ *
+ * @property SCROLLBAR_TEMPLATE
+ * @type Object
+ * @static
+ */
+ScrollbarsPlugin.SCROLLBAR_TEMPLATE = [
+    '<div>',
+    '<span class="' + _classNames.child + ' ' + _classNames.first + '"></span>',
+    '<span class="' + _classNames.child + ' ' + _classNames.middle + '"></span>',
+    '<span class="' + _classNames.child + ' ' + _classNames.last + '"></span>',
+    '</div>'
+].join('');
+
+/**
+ * The default attribute configuration for the plugin
+ *
+ * @property ATTRS
+ * @type Object
+ * @static
+ */
+ScrollbarsPlugin.ATTRS = {
+    
+    /**
+     * Vertical scrollbar node
+     *
+     * @attribute verticalNode
+     * @type Y.Node
+     */
+    verticalNode: {
+        setter: '_setNode',
+        valueFn: '_defaultNode'
+    },
+
+    /**
+     * Horizontal scrollbar node
+     *
+     * @attribute horizontalNode
+     * @type Y.Node
+     */
+    horizontalNode: {
+        setter: '_setNode',
+        valueFn: '_defaultNode'
+    }
+};
+
+Y.namespace("Plugin").ScrollViewScrollbars = Y.extend(ScrollbarsPlugin, Y.Plugin.Base, {
+
+    /**
+     * Designated initializer
+     *
+     * @method initializer
+     */
+    initializer: function() {
+        this._host = this.get("host");
+
+        this.afterHostEvent('scrollEnd', this._hostScrollEnd);
+        this.afterHostMethod('scrollTo', this._update);
+        this.afterHostMethod('_uiDimensionsChange', this._hostDimensionsChange);
+    },
+
+    /**
+     * Set up the DOM nodes for the scrollbars. This method is invoked whenever the
+     * host's _uiDimensionsChange fires, giving us the opportunity to remove un-needed
+     * scrollbars, as well as add one if necessary.
+     *
+     * @method _hostDimensionsChange
+     * @protected
+     */
+    _hostDimensionsChange: function() {
+        var host = this._host,
+            axis = host._cAxis,
+            scrollX = host.get(SCROLL_X),
+            scrollY = host.get(SCROLL_Y);
+
+        this._dims = host._getScrollDims();
+
+        if (axis && axis.y) {
+            this._renderBar(this.get(VERTICAL_NODE), true, 'vert');
+        }
+
+        if (axis && axis.x) {
+            this._renderBar(this.get(HORIZONTAL_NODE), true, 'horiz');
+        }
+
+        this._update(scrollX, scrollY);
+
+        Y.later(500, this, 'flash', true);
+    },
+
+    /**
+     * Handler for the scrollEnd event fired by the host. Default implementation flashes the scrollbar
+     *
+     * @method _hostScrollEnd
+     * @param {Event.Facade} e The event facade.
+     * @protected
+     */
+    _hostScrollEnd : function() {
+        var host = this._host,
+            scrollX = host.get(SCROLL_X),
+            scrollY = host.get(SCROLL_Y);
+
+        this.flash();
+
+        this._update(scrollX, scrollY);
+    },
+
+    /**
+     * Adds or removes a scrollbar node from the document.
+     *
+     * @method _renderBar
+     * @private
+     * @param {Node} bar The scrollbar node
+     * @param {boolean} add true, to add the node, false to remove it
+     */
+    _renderBar: function(bar, add) {
+        var inDoc = bar.inDoc(),
+            bb = this._host._bb,
+            className = bar.getData("isHoriz") ? _classNames.scrollbarHB : _classNames.scrollbarVB;
+
+        if (add && !inDoc) {
+            bb.append(bar);
+            bar.toggleClass(className, this._basic);
+            this._setChildCache(bar);
+        } else if(!add && inDoc) {
+            bar.remove();
+            this._clearChildCache(bar);
+        }
+    },
+
+    /**
+     * Caches scrollbar child element information,
+     * to optimize _update implementation
+     *
+     * @method _setChildCache
+     * @private
+     * @param {Node} node
+     */
+    _setChildCache : function(node) {
+        var c = node.get("children"),
+            fc = c.item(0),
+            mc = c.item(1),
+            lc = c.item(2),
+            size = node.getData("isHoriz") ? "offsetWidth" : "offsetHeight";
+
+        node.setStyle(TRANSITION_PROPERTY, TRANSFORM);
+        mc.setStyle(TRANSITION_PROPERTY, TRANSFORM);
+        lc.setStyle(TRANSITION_PROPERTY, TRANSFORM);
+
+        node.setData(CHILD_CACHE, {
+            fc : fc,
+            lc : lc,
+            mc : mc,
+            fcSize : fc && fc.get(size),
+            lcSize : lc && lc.get(size)
+        });
+    },
+
+    /**
+     * Clears child cache
+     *
+     * @method _clearChildCache
+     * @private
+     * @param {Node} node
+     */
+    _clearChildCache : function(node) {
+        node.clearData(CHILD_CACHE);
+    },
+
+    /**
+     * Utility method, to move/resize either vertical or horizontal scrollbars
+     *
+     * @method _updateBar
+     * @private
+     *
+     * @param {Node} scrollbar The scrollbar node.
+     * @param {Number} current The current scroll position.
+     * @param {Number} duration The transition duration.
+     * @param {boolean} horiz true if horizontal, false if vertical.
+     */
+    _updateBar : function(scrollbar, current, duration, horiz) {
+
+        var host = this._host,
+            basic = this._basic,
+
+            scrollbarSize = 0,
+            scrollbarPos = 1,
+
+            childCache = scrollbar.getData(CHILD_CACHE),
+            lastChild = childCache.lc,
+            middleChild = childCache.mc,
+            firstChildSize = childCache.fcSize,
+            lastChildSize = childCache.lcSize,
+            middleChildSize,
+            lastChildPosition,
+
+            transition,
+            translate,
+            scale,
+
+            dim,
+            dimOffset,
+            dimCache,
+            widgetSize,
+            contentSize;
+
+        if (horiz) {
+            dim = WIDTH;
+            dimOffset = LEFT;
+            dimCache = HORIZ_CACHE;
+            widgetSize = this._dims.offsetWidth;
+            contentSize = this._dims.scrollWidth;
+            translate = TRANSLATE_X;
+            scale = SCALE_X;
+            current = (current !== undefined) ? current : host.get(SCROLL_X);
+        } else {
+            dim = HEIGHT;
+            dimOffset = TOP;
+            dimCache = VERT_CACHE;
+            widgetSize = this._dims.offsetHeight;
+            contentSize = this._dims.scrollHeight;
+            translate = TRANSLATE_Y;
+            scale = SCALE_Y;
+            current = (current !== undefined) ? current : host.get(SCROLL_Y);
+        }
+
+        scrollbarSize = Math.floor(widgetSize * (widgetSize/contentSize));
+        scrollbarPos = Math.floor((current/(contentSize - widgetSize)) * (widgetSize - scrollbarSize));
+        if (scrollbarSize > widgetSize) {
+            scrollbarSize = 1;
+        }
+
+        if (scrollbarPos > (widgetSize - scrollbarSize)) {
+            scrollbarSize = scrollbarSize - (scrollbarPos - (widgetSize - scrollbarSize));
+        } else if (scrollbarPos < 0) {
+            scrollbarSize = scrollbarPos + scrollbarSize;
+            scrollbarPos = 0;
+        } else if (isNaN(scrollbarPos)) {
+            scrollbarPos = 0;
+        }
+
+        middleChildSize = (scrollbarSize - (firstChildSize + lastChildSize));
+
+        if (middleChildSize < 0) {
+            middleChildSize = 0;
+        }
+
+        if (middleChildSize === 0 && scrollbarPos !== 0) {
+            scrollbarPos = widgetSize - (firstChildSize + lastChildSize) - 1;
+        }
+
+        if (duration !== 0) {
+            // Position Scrollbar
+            transition = {
+                duration : duration
+            };
+
+            if (NATIVE_TRANSITIONS) {
+                transition.transform = translate + scrollbarPos + PX_CLOSE;
+            } else {
+                transition[dimOffset] = scrollbarPos + PX;
+            }
+
+            scrollbar.transition(transition);
+
+        } else {
+            if (NATIVE_TRANSITIONS) {
+                scrollbar.setStyle(TRANSFORM, translate + scrollbarPos + PX_CLOSE);
+            } else {
+                scrollbar.setStyle(dimOffset, scrollbarPos + PX);
+            }
+        }
+
+        // Resize Scrollbar Middle Child
+        if (this[dimCache] !== middleChildSize) {
+            this[dimCache] = middleChildSize;
+
+            if (middleChildSize > 0) {
+
+                if (duration !== 0) {
+                    transition = {
+                        duration : duration
+                    };
+
+                    if(NATIVE_TRANSITIONS) {
+                        transition.transform = scale + middleChildSize + CLOSE;
+                    } else {
+                        transition[dim] = middleChildSize + PX;
+                    }
+
+                    middleChild.transition(transition);
+                } else {
+                    if (NATIVE_TRANSITIONS) {
+                        middleChild.setStyle(TRANSFORM, scale + middleChildSize + CLOSE);
+                    } else {
+                        middleChild.setStyle(dim, middleChildSize + PX);
+                    }
+                }
+    
+                // Position Last Child
+                if (!horiz || !basic) {
+
+                    lastChildPosition = scrollbarSize - lastChildSize;
+    
+                    if(duration !== 0) {
+                        transition = {
+                            duration : duration
+                        };
+                
+                        if (NATIVE_TRANSITIONS) {
+                            transition.transform = translate + lastChildPosition + PX_CLOSE;
+                        } else {
+                            transition[dimOffset] = lastChildPosition;
+                        }
+
+                        lastChild.transition(transition);
+                    } else {
+                        if (NATIVE_TRANSITIONS) {
+                            lastChild.setStyle(TRANSFORM, translate + lastChildPosition + PX_CLOSE);
+                        } else {
+                            lastChild.setStyle(dimOffset, lastChildPosition + PX);
+                        }
+                    }
+                }
+            }
+        }
+    },
+
+    /**
+     * AOP method, invoked after the host's _uiScrollTo method,
+     *  to position and resize the scroll bars
+     *
+     * @method _update
+     * @param x {Number} The current scrollX value
+     * @param y {Number} The current scrollY value
+     * @param duration {Number} Number of ms of animation (optional) - used when snapping to bounds
+     * @param easing {String} Optional easing equation to use during the animation, if duration is set
+     * @protected
+     */
+    _update: function(x, y, duration) {
+        var vNode = this.get(VERTICAL_NODE),
+            hNode = this.get(HORIZONTAL_NODE),
+            host = this._host,
+            axis = host._cAxis;
+
+        duration = (duration || 0)/1000;
+
+        if (!this._showing) {
+            this.show();
+        }
+
+        if (axis && axis.y && vNode && y !== null) {
+            this._updateBar(vNode, y, duration, false);
+        }
+
+        if (axis && axis.x && hNode && x !== null) {
+            this._updateBar(hNode, x, duration, true);
+        }
+    },
+
+    /**
+     * Show the scroll bar indicators
+     *
+     * @method show
+     * @param animated {Boolean} Whether or not to animate the showing
+     */
+    show: function(animated) {
+        this._show(true, animated);
+    },
+
+    /**
+     * Hide the scroll bar indicators
+     *
+     * @method hide
+     * @param animated {Boolean} Whether or not to animate the hiding
+     */
+    hide: function(animated) {
+        this._show(false, animated);
+    },
+
+    /**
+     * Internal hide/show implementation utility method
+     *
+     * @method _show
+     * @param {boolean} show Whether to show or hide the scrollbar
+     * @param {bolean} animated Whether or not to animate while showing/hide
+     * @protected
+     */
+    _show : function(show, animated) {
+
+        var verticalNode = this.get(VERTICAL_NODE),
+            horizontalNode = this.get(HORIZONTAL_NODE),
+
+            duration = (animated) ? 0.6 : 0,
+            opacity = (show) ? 1 : 0,
+
+            transition;
+
+        this._showing = show;
+
+        if (this._flashTimer) {
+            this._flashTimer.cancel();
+        }
+
+        transition = {
+            duration : duration,
+            opacity : opacity
+        };
+
+        if (verticalNode && verticalNode._node) {
+            verticalNode.transition(transition);
+        }
+
+        if (horizontalNode && horizontalNode._node) {
+            horizontalNode.transition(transition);
+        }
+    },
+
+    /**
+     * Momentarily flash the scroll bars to indicate current scroll position
+     *
+     * @method flash
+     */
+    flash: function() {
+        this.show(true);
+        this._flashTimer = Y.later(800, this, 'hide', true);
+    },
+
+    /**
+     * Setter for the verticalNode and horizontalNode attributes
+     *
+     * @method _setNode
+     * @param node {Node} The Y.Node instance for the scrollbar
+     * @param name {String} The attribute name
+     * @return {Node} The Y.Node instance for the scrollbar
+     *
+     * @protected
+     */
+    _setNode: function(node, name) {
+        var horiz = (name === HORIZONTAL_NODE);
+            node = Y.one(node);
+
+        if (node) {
+            node.addClass(_classNames.scrollbar);
+            node.addClass( (horiz) ? _classNames.scrollbarH : _classNames.scrollbarV );
+            node.setData("isHoriz", horiz);
+        }
+
+        return node;
+    },
+
+    /**
+     * Creates default node instances for scrollbars
+     *
+     * @method _defaultNode
+     * @return {Node} The Y.Node instance for the scrollbar
+     *
+     * @protected
+     */
+    _defaultNode: function() {
+        return Y.Node.create(ScrollbarsPlugin.SCROLLBAR_TEMPLATE);
+    },
+
+    _basic: Y.UA.ie && Y.UA.ie <= 8
+
+});
+
+
+}, '3.10.3', {"requires": ["classnamemanager", "transition", "plugin"], "skinnable": true});