/**
* Support for Widget UI Events (Custom Events fired by the widget, which wrap the underlying DOM events - e.g. widget:click, widget:mousedown)
*
* @module widget
* @submodule widget-uievents
*/
var BOUNDING_BOX = "boundingBox",
Widget = Y.Widget,
RENDER = "render",
L = Y.Lang,
EVENT_PREFIX_DELIMITER = ":",
// Map of Node instances serving as a delegation containers for a specific
// event type to Widget instances using that delegation container.
_uievts = Y.Widget._uievts = Y.Widget._uievts || {};
Y.mix(Widget.prototype, {
/**
* Destructor logic for UI event infrastructure,
* invoked during Widget destruction.
*
* @method _destroyUIEvents
* @for Widget
* @private
*/
_destroyUIEvents: function() {
var widgetGuid = Y.stamp(this, true);
Y.each(_uievts, function (info, key) {
if (info.instances[widgetGuid]) {
// Unregister this Widget instance as needing this delegated
// event listener.
delete info.instances[widgetGuid];
// There are no more Widget instances using this delegated
// event listener, so detach it.
if (Y.Object.isEmpty(info.instances)) {
info.handle.detach();
if (_uievts[key]) {
delete _uievts[key];
}
}
}
});
},
/**
* Map of DOM events that should be fired as Custom Events by the
* Widget instance.
*
* @property UI_EVENTS
* @for Widget
* @type Object
*/
UI_EVENTS: Y.Node.DOM_EVENTS,
/**
* Returns the node on which to bind delegate listeners.
*
* @method _getUIEventNode
* @for Widget
* @protected
*/
_getUIEventNode: function () {
return this.get(BOUNDING_BOX);
},
/**
* Binds a delegated DOM event listener of the specified type to the
* Widget's outtermost DOM element to facilitate the firing of a Custom
* Event of the same type for the Widget instance.
*
* @method _createUIEvent
* @for Widget
* @param type {String} String representing the name of the event
* @private
*/
_createUIEvent: function (type) {
var uiEvtNode = this._getUIEventNode(),
key = (Y.stamp(uiEvtNode) + type),
info = _uievts[key],
handle;
// For each Node instance: Ensure that there is only one delegated
// event listener used to fire Widget UI events.
if (!info) {
handle = uiEvtNode.delegate(type, function (evt) {
var widget = Widget.getByNode(this);
// Widget could be null if node instance belongs to
// another Y instance.
if (widget) {
if (widget._filterUIEvent(evt)) {
widget.fire(evt.type, { domEvent: evt });
}
}
}, "." + Y.Widget.getClassName());
_uievts[key] = info = { instances: {}, handle: handle };
}
// Register this Widget as using this Node as a delegation container.
info.instances[Y.stamp(this)] = 1;
},
/**
* This method is used to determine if we should fire
* the UI Event or not. The default implementation makes sure
* that for nested delegates (nested unrelated widgets), we don't
* fire the UI event listener more than once at each level.
*
* <p>For example, without the additional filter, if you have nested
* widgets, each widget will have a delegate listener. If you
* click on the inner widget, the inner delegate listener's
* filter will match once, but the outer will match twice
* (based on delegate's design) - once for the inner widget,
* and once for the outer.</p>
*
* @method _filterUIEvent
* @for Widget
* @param {DOMEventFacade} evt
* @return {boolean} true if it's OK to fire the custom UI event, false if not.
* @private
*
*/
_filterUIEvent: function(evt) {
// Either it's hitting this widget's delegate container (and not some other widget's),
// or the container it's hitting is handling this widget's ui events.
return (evt.currentTarget.compareTo(evt.container) || evt.container.compareTo(this._getUIEventNode()));
},
/**
* Determines if the specified event is a UI event.
*
* @private
* @method _isUIEvent
* @for Widget
* @param type {String} String representing the name of the event
* @return {String} Event Returns the name of the UI Event, otherwise
* undefined.
*/
_getUIEvent: function (type) {
if (L.isString(type)) {
var sType = this.parseType(type)[1],
iDelim,
returnVal;
if (sType) {
// TODO: Get delimiter from ET, or have ET support this.
iDelim = sType.indexOf(EVENT_PREFIX_DELIMITER);
if (iDelim > -1) {
sType = sType.substring(iDelim + EVENT_PREFIX_DELIMITER.length);
}
if (this.UI_EVENTS[sType]) {
returnVal = sType;
}
}
return returnVal;
}
},
/**
* Sets up infrastructure required to fire a UI event.
*
* @private
* @method _initUIEvent
* @for Widget
* @param type {String} String representing the name of the event
* @return {String}
*/
_initUIEvent: function (type) {
var sType = this._getUIEvent(type),
queue = this._uiEvtsInitQueue || {};
if (sType && !queue[sType]) {
Y.log("Deferring creation of " + type + " delegate until render.", "info", "widget");
this._uiEvtsInitQueue = queue[sType] = 1;
this.after(RENDER, function() {
this._createUIEvent(sType);
delete this._uiEvtsInitQueue[sType];
});
}
},
// Override of "on" from Base to facilitate the firing of Widget events
// based on DOM events of the same name/type (e.g. "click", "mouseover").
// Temporary solution until we have the ability to listen to when
// someone adds an event listener (bug 2528230)
on: function (type) {
this._initUIEvent(type);
return Widget.superclass.on.apply(this, arguments);
},
// Override of "publish" from Base to facilitate the firing of Widget events
// based on DOM events of the same name/type (e.g. "click", "mouseover").
// Temporary solution until we have the ability to listen to when
// someone publishes an event (bug 2528230)
publish: function (type, config) {
var sType = this._getUIEvent(type);
if (sType && config && config.defaultFn) {
this._initUIEvent(sType);
}
return Widget.superclass.publish.apply(this, arguments);
}
}, true); // overwrite existing EventTarget methods
