diff -r 322d0feea350 -r 89ef5ed3c48b src/cm/media/js/lib/yui/yui_3.10.3/build/plugin/plugin-debug.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cm/media/js/lib/yui/yui_3.10.3/build/plugin/plugin-debug.js Tue Jul 16 14:29:46 2013 +0200 @@ -0,0 +1,236 @@ +/* +YUI 3.10.3 (build 2fb5187) +Copyright 2013 Yahoo! Inc. All rights reserved. +Licensed under the BSD License. +http://yuilibrary.com/license/ +*/ + +YUI.add('plugin', function (Y, NAME) { + + /** + * Provides the base Plugin class, which plugin developers should extend, when creating custom plugins + * + * @module plugin + */ + + /** + * The base class for all Plugin instances. + * + * @class Plugin.Base + * @extends Base + * @param {Object} config Configuration object with property name/value pairs. + */ + function Plugin(config) { + if (! (this.hasImpl && this.hasImpl(Y.Plugin.Base)) ) { + Plugin.superclass.constructor.apply(this, arguments); + } else { + Plugin.prototype.initializer.apply(this, arguments); + } + } + + /** + * Object defining the set of attributes supported by the Plugin.Base class + * + * @property ATTRS + * @type Object + * @static + */ + Plugin.ATTRS = { + + /** + * The plugin's host object. + * + * @attribute host + * @writeonce + * @type Plugin.Host + */ + host : { + writeOnce: true + } + }; + + /** + * The string identifying the Plugin.Base class. Plugins extending + * Plugin.Base should set their own NAME value. + * + * @property NAME + * @type String + * @static + */ + Plugin.NAME = 'plugin'; + + /** + * The name of the property the the plugin will be attached to + * when plugged into a Plugin Host. Plugins extending Plugin.Base, + * should set their own NS value. + * + * @property NS + * @type String + * @static + */ + Plugin.NS = 'plugin'; + + Y.extend(Plugin, Y.Base, { + + /** + * The list of event handles for event listeners or AOP injected methods + * applied by the plugin to the host object. + * + * @property _handles + * @private + * @type Array + * @value null + */ + _handles: null, + + /** + * Initializer lifecycle implementation. + * + * @method initializer + * @param {Object} config Configuration object with property name/value pairs. + */ + initializer : function(config) { + if (!this.get("host")) { Y.log('No host defined for plugin ' + this, 'warn', 'Plugin');} + this._handles = []; + Y.log('Initializing: ' + this.constructor.NAME, 'info', 'Plugin'); + }, + + /** + * Destructor lifecycle implementation. + * + * Removes any event listeners or injected methods applied by the Plugin + * + * @method destructor + */ + destructor: function() { + // remove all handles + if (this._handles) { + for (var i = 0, l = this._handles.length; i < l; i++) { + this._handles[i].detach(); + } + } + }, + + /** + * Listens for the "on" moment of events fired by the host, + * or injects code "before" a given method on the host. + * + * @method doBefore + * + * @param strMethod {String} The event to listen for, or method to inject logic before. + * @param fn {Function} The handler function. For events, the "on" moment listener. For methods, the function to execute before the given method is executed. + * @param context {Object} An optional context to call the handler with. The default context is the plugin instance. + * @return handle {EventHandle} The detach handle for the handler. + */ + doBefore: function(strMethod, fn, context) { + var host = this.get("host"), handle; + + if (strMethod in host) { // method + handle = this.beforeHostMethod(strMethod, fn, context); + } else if (host.on) { // event + handle = this.onHostEvent(strMethod, fn, context); + } + + return handle; + }, + + /** + * Listens for the "after" moment of events fired by the host, + * or injects code "after" a given method on the host. + * + * @method doAfter + * + * @param strMethod {String} The event to listen for, or method to inject logic after. + * @param fn {Function} The handler function. For events, the "after" moment listener. For methods, the function to execute after the given method is executed. + * @param context {Object} An optional context to call the handler with. The default context is the plugin instance. + * @return handle {EventHandle} The detach handle for the listener. + */ + doAfter: function(strMethod, fn, context) { + var host = this.get("host"), handle; + + if (strMethod in host) { // method + handle = this.afterHostMethod(strMethod, fn, context); + } else if (host.after) { // event + handle = this.afterHostEvent(strMethod, fn, context); + } + + return handle; + }, + + /** + * Listens for the "on" moment of events fired by the host object. + * + * Listeners attached through this method will be detached when the plugin is unplugged. + * + * @method onHostEvent + * @param {String | Object} type The event type. + * @param {Function} fn The listener. + * @param {Object} context The execution context. Defaults to the plugin instance. + * @return handle {EventHandle} The detach handle for the listener. + */ + onHostEvent : function(type, fn, context) { + var handle = this.get("host").on(type, fn, context || this); + this._handles.push(handle); + return handle; + }, + + /** + * Listens for the "after" moment of events fired by the host object. + * + * Listeners attached through this method will be detached when the plugin is unplugged. + * + * @method afterHostEvent + * @param {String | Object} type The event type. + * @param {Function} fn The listener. + * @param {Object} context The execution context. Defaults to the plugin instance. + * @return handle {EventHandle} The detach handle for the listener. + */ + afterHostEvent : function(type, fn, context) { + var handle = this.get("host").after(type, fn, context || this); + this._handles.push(handle); + return handle; + }, + + /** + * Injects a function to be executed before a given method on host object. + * + * The function will be detached when the plugin is unplugged. + * + * @method beforeHostMethod + * @param {String} method The name of the method to inject the function before. + * @param {Function} fn The function to inject. + * @param {Object} context The execution context. Defaults to the plugin instance. + * @return handle {EventHandle} The detach handle for the injected function. + */ + beforeHostMethod : function(strMethod, fn, context) { + var handle = Y.Do.before(fn, this.get("host"), strMethod, context || this); + this._handles.push(handle); + return handle; + }, + + /** + * Injects a function to be executed after a given method on host object. + * + * The function will be detached when the plugin is unplugged. + * + * @method afterHostMethod + * @param {String} method The name of the method to inject the function after. + * @param {Function} fn The function to inject. + * @param {Object} context The execution context. Defaults to the plugin instance. + * @return handle {EventHandle} The detach handle for the injected function. + */ + afterHostMethod : function(strMethod, fn, context) { + var handle = Y.Do.after(fn, this.get("host"), strMethod, context || this); + this._handles.push(handle); + return handle; + }, + + toString: function() { + return this.constructor.NAME + '[' + this.constructor.NS + ']'; + } + }); + + Y.namespace("Plugin").Base = Plugin; + + +}, '3.10.3', {"requires": ["base-base"]});