/**
                             * Return value from all subscribe operations
                             * @class EventHandle
                             * @constructor
                             * @param {CustomEvent} evt the custom event.
                             * @param {Subscriber} sub the subscriber.
                             */
                            Y.EventHandle = function(evt, sub) {
                            
                                /**
                                 * The custom event
                                 *
                                 * @property evt
                                 * @type CustomEvent
                                 */
                                this.evt = evt;
                            
                                /**
                                 * The subscriber object
                                 *
                                 * @property sub
                                 * @type Subscriber
                                 */
                                this.sub = sub;
                            };
                            
                            Y.EventHandle.prototype = {
                                batch: function(f, c) {
                                    f.call(c || this, this);
                                    if (Y.Lang.isArray(this.evt)) {
                                        Y.Array.each(this.evt, function(h) {
                                            h.batch.call(c || h, f);
                                        });
                                    }
                                },
                            
                                /**
                                 * Detaches this subscriber
                                 * @method detach
                                 * @return {Number} the number of detached listeners
                                 */
                                detach: function() {
                                    var evt = this.evt, detached = 0, i;
                                    if (evt) {
                                        // Y.log('EventHandle.detach: ' + this.sub, 'info', 'Event');
                                        if (Y.Lang.isArray(evt)) {
                                            for (i = 0; i < evt.length; i++) {
                                                detached += evt[i].detach();
                                            }
                                        } else {
                                            evt._delete(this.sub);
                                            detached = 1;
                                        }
                            
                                    }
                            
                                    return detached;
                                },
                            
                                /**
                                 * Monitor the event state for the subscribed event.  The first parameter
                                 * is what should be monitored, the rest are the normal parameters when
                                 * subscribing to an event.
                                 * @method monitor
                                 * @param what {string} what to monitor ('attach', 'detach', 'publish').
                                 * @return {EventHandle} return value from the monitor event subscription.
                                 */
                                monitor: function(what) {
                                    return this.evt.monitor.apply(this.evt, arguments);
                                }
                            };