diff -r 322d0feea350 -r 89ef5ed3c48b src/cm/media/js/lib/yui/yui_3.10.3/build/event-focus/event-focus.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cm/media/js/lib/yui/yui_3.10.3/build/event-focus/event-focus.js Tue Jul 16 14:29:46 2013 +0200 @@ -0,0 +1,280 @@ +/* +YUI 3.10.3 (build 2fb5187) +Copyright 2013 Yahoo! Inc. All rights reserved. +Licensed under the BSD License. +http://yuilibrary.com/license/ +*/ + +YUI.add('event-focus', function (Y, NAME) { + +/** + * Adds bubbling and delegation support to DOM events focus and blur. + * + * @module event + * @submodule event-focus + */ +var Event = Y.Event, + + YLang = Y.Lang, + + isString = YLang.isString, + + arrayIndex = Y.Array.indexOf, + + useActivate = (function() { + + // Changing the structure of this test, so that it doesn't use inline JS in HTML, + // which throws an exception in Win8 packaged apps, due to additional security restrictions: + // http://msdn.microsoft.com/en-us/library/windows/apps/hh465380.aspx#differences + + var supported = false, + doc = Y.config.doc, + p; + + if (doc) { + + p = doc.createElement("p"); + p.setAttribute("onbeforeactivate", ";"); + + // onbeforeactivate is a function in IE8+. + // onbeforeactivate is a string in IE6,7 (unfortunate, otherwise we could have just checked for function below). + // onbeforeactivate is a function in IE10, in a Win8 App environment (no exception running the test). + + // onbeforeactivate is undefined in Webkit/Gecko. + // onbeforeactivate is a function in Webkit/Gecko if it's a supported event (e.g. onclick). + + supported = (p.onbeforeactivate !== undefined); + } + + return supported; + }()); + +function define(type, proxy, directEvent) { + var nodeDataKey = '_' + type + 'Notifiers'; + + Y.Event.define(type, { + + _useActivate : useActivate, + + _attach: function (el, notifier, delegate) { + if (Y.DOM.isWindow(el)) { + return Event._attach([type, function (e) { + notifier.fire(e); + }, el]); + } else { + return Event._attach( + [proxy, this._proxy, el, this, notifier, delegate], + { capture: true }); + } + }, + + _proxy: function (e, notifier, delegate) { + var target = e.target, + currentTarget = e.currentTarget, + notifiers = target.getData(nodeDataKey), + yuid = Y.stamp(currentTarget._node), + defer = (useActivate || target !== currentTarget), + directSub; + + notifier.currentTarget = (delegate) ? target : currentTarget; + notifier.container = (delegate) ? currentTarget : null; + + // Maintain a list to handle subscriptions from nested + // containers div#a>div#b>input #a.on(focus..) #b.on(focus..), + // use one focus or blur subscription that fires notifiers from + // #b then #a to emulate bubble sequence. + if (!notifiers) { + notifiers = {}; + target.setData(nodeDataKey, notifiers); + + // only subscribe to the element's focus if the target is + // not the current target ( + if (defer) { + directSub = Event._attach( + [directEvent, this._notify, target._node]).sub; + directSub.once = true; + } + } else { + // In old IE, defer is always true. In capture-phase browsers, + // The delegate subscriptions will be encountered first, which + // will establish the notifiers data and direct subscription + // on the node. If there is also a direct subscription to the + // node's focus/blur, it should not call _notify because the + // direct subscription from the delegate sub(s) exists, which + // will call _notify. So this avoids _notify being called + // twice, unnecessarily. + defer = true; + } + + if (!notifiers[yuid]) { + notifiers[yuid] = []; + } + + notifiers[yuid].push(notifier); + + if (!defer) { + this._notify(e); + } + }, + + _notify: function (e, container) { + var currentTarget = e.currentTarget, + notifierData = currentTarget.getData(nodeDataKey), + axisNodes = currentTarget.ancestors(), + doc = currentTarget.get('ownerDocument'), + delegates = [], + // Used to escape loops when there are no more + // notifiers to consider + count = notifierData ? + Y.Object.keys(notifierData).length : + 0, + target, notifiers, notifier, yuid, match, tmp, i, len, sub, ret; + + // clear the notifications list (mainly for delegation) + currentTarget.clearData(nodeDataKey); + + // Order the delegate subs by their placement in the parent axis + axisNodes.push(currentTarget); + // document.get('ownerDocument') returns null + // which we'll use to prevent having duplicate Nodes in the list + if (doc) { + axisNodes.unshift(doc); + } + + // ancestors() returns the Nodes from top to bottom + axisNodes._nodes.reverse(); + + if (count) { + // Store the count for step 2 + tmp = count; + axisNodes.some(function (node) { + var yuid = Y.stamp(node), + notifiers = notifierData[yuid], + i, len; + + if (notifiers) { + count--; + for (i = 0, len = notifiers.length; i < len; ++i) { + if (notifiers[i].handle.sub.filter) { + delegates.push(notifiers[i]); + } + } + } + + return !count; + }); + count = tmp; + } + + // Walk up the parent axis, notifying direct subscriptions and + // testing delegate filters. + while (count && (target = axisNodes.shift())) { + yuid = Y.stamp(target); + + notifiers = notifierData[yuid]; + + if (notifiers) { + for (i = 0, len = notifiers.length; i < len; ++i) { + notifier = notifiers[i]; + sub = notifier.handle.sub; + match = true; + + e.currentTarget = target; + + if (sub.filter) { + match = sub.filter.apply(target, + [target, e].concat(sub.args || [])); + + // No longer necessary to test against this + // delegate subscription for the nodes along + // the parent axis. + delegates.splice( + arrayIndex(delegates, notifier), 1); + } + + if (match) { + // undefined for direct subs + e.container = notifier.container; + ret = notifier.fire(e); + } + + if (ret === false || e.stopped === 2) { + break; + } + } + + delete notifiers[yuid]; + count--; + } + + if (e.stopped !== 2) { + // delegates come after subs targeting this specific node + // because they would not normally report until they'd + // bubbled to the container node. + for (i = 0, len = delegates.length; i < len; ++i) { + notifier = delegates[i]; + sub = notifier.handle.sub; + + if (sub.filter.apply(target, + [target, e].concat(sub.args || []))) { + + e.container = notifier.container; + e.currentTarget = target; + ret = notifier.fire(e); + } + + if (ret === false || e.stopped === 2) { + break; + } + } + } + + if (e.stopped) { + break; + } + } + }, + + on: function (node, sub, notifier) { + sub.handle = this._attach(node._node, notifier); + }, + + detach: function (node, sub) { + sub.handle.detach(); + }, + + delegate: function (node, sub, notifier, filter) { + if (isString(filter)) { + sub.filter = function (target) { + return Y.Selector.test(target._node, filter, + node === target ? null : node._node); + }; + } + + sub.handle = this._attach(node._node, notifier, true); + }, + + detachDelegate: function (node, sub) { + sub.handle.detach(); + } + }, true); +} + +// For IE, we need to defer to focusin rather than focus because +// `el.focus(); doSomething();` executes el.onbeforeactivate, el.onactivate, +// el.onfocusin, doSomething, then el.onfocus. All others support capture +// phase focus, which executes before doSomething. To guarantee consistent +// behavior for this use case, IE's direct subscriptions are made against +// focusin so subscribers will be notified before js following el.focus() is +// executed. +if (useActivate) { + // name capture phase direct subscription + define("focus", "beforeactivate", "focusin"); + define("blur", "beforedeactivate", "focusout"); +} else { + define("focus", "focus", "focus"); + define("blur", "blur", "blur"); +} + + +}, '3.10.3', {"requires": ["event-synthetic"]});