• Classes
• Modules
• Everything

 /**
 * A Button Plugin
 *
 * @module button-plugin
 * @since 3.5.0
 */
 
 /**
 * @class Button
 * @param config {Object} Configuration object
 * @extends ButtonCore
 * @constructor
 * @namespace Plugin
 */
 function ButtonPlugin() {
 ButtonPlugin.superclass.constructor.apply(this, arguments);
 }
 
 Y.extend(ButtonPlugin, Y.ButtonCore, {
 
 /**
 * @method _afterNodeGet
 * @param name {string}
 * @private
 */
 _afterNodeGet: function (name) {
 // TODO: point to method (_uiSetLabel, etc) instead of getter/setter
 var ATTRS = this.constructor.ATTRS,
 fn = ATTRS[name] && ATTRS[name].getter && this[ATTRS[name].getter];
 
 if (fn) {
 return new Y.Do.AlterReturn('get ' + name, fn.call(this));
 }
 },
 
 /**
 * @method _afterNodeSet
 * @param name {String}
 * @param val {String}
 * @private
 */
 _afterNodeSet: function (name, val) {
 var ATTRS = this.constructor.ATTRS,
 fn = ATTRS[name] && ATTRS[name].setter && this[ATTRS[name].setter];
 
 if (fn) {
 fn.call(this, val);
 }
 },
 
 /**
 * @method _initNode
 * @param config {Object}
 * @private
 */
 _initNode: function(config) {
 var node = config.host;
 this._host = node;
 
 Y.Do.after(this._afterNodeGet, node, 'get', this);
 Y.Do.after(this._afterNodeSet, node, 'set', this);
 },
 
 /**
 * @method destroy
 * @private
 */
 destroy: function(){
 // Nothing to do, but things are happier with it here
 }
 
 }, {
 
 /**
 * Attribute configuration.
 *
 * @property ATTRS
 * @type {Object}
 * @private
 * @static
 */
 ATTRS: Y.merge(Y.ButtonCore.ATTRS),
 
 /**
 * Name of this component.
 *
 * @property NAME
 * @type String
 * @static
 */
 NAME: 'buttonPlugin',
 
 /**
 * Namespace of this component.
 *
 * @property NS
 * @type String
 * @static
 */
 NS: 'button'
 
 });
 
 /**
 * @method createNode
 * @description A factory that plugs a Y.Node instance with Y.Plugin.Button
 * @param node {Object}
 * @param config {Object}
 * @return {Object} A plugged Y.Node instance
 * @public
 */
 ButtonPlugin.createNode = function(node, config) {
 var template;
 
 if (node && !config) {
 if (! (node.nodeType || node.getDOMNode || typeof node === 'string')) {
 config = node;
 node = config.srcNode;
 }
 }
 
 config = config || {};
 template = config.template || Y.Plugin.Button.prototype.TEMPLATE;
 node = node || config.srcNode || Y.DOM.create(template);
 
 return Y.one(node).plug(Y.Plugin.Button, config);
 };
 
 Y.namespace('Plugin').Button = ButtonPlugin;