From 32f85e42e426970c76ec9a1099b584ea2afb7fad Mon Sep 17 00:00:00 2001 From: rolux Date: Sat, 30 Jun 2012 11:24:03 +0200 Subject: [PATCH] new event controller --- source/Ox.UI/js/Core/Event.js | 257 ++++++++++++++++++---------------- 1 file changed, 137 insertions(+), 120 deletions(-) diff --git a/source/Ox.UI/js/Core/Event.js b/source/Ox.UI/js/Core/Event.js index 9170805b..0e44d538 100644 --- a/source/Ox.UI/js/Core/Event.js +++ b/source/Ox.UI/js/Core/Event.js @@ -1,157 +1,174 @@ 'use strict'; /*@ -Ox.Event Basic event handler +Ox.Event Used internally for events @*/ -// FIXME: unused - Ox.Event = (function() { - var that = {}; + var eventHandlers = [], + that = {}; + + function log(data, event, self) { + var element = this, + handlers = self.eventHandlers ? self.eventHandlers[event] : []; + if (!Ox.contains([ + 'mousedown', 'mouserepeat', 'anyclick', 'singleclick', 'doubleclick', + 'dragstart', 'drag', 'dragenter', 'dragleave', 'dragpause', 'dragend', + 'draganddropstart', 'draganddrop', 'draganddropenter', 'draganddropleave', 'draganddropend', + 'playing', 'position', 'progress' + ], event)) { + try { + data = JSON.stringify(data) + } catch(e) {} + Ox.print( + 'EVENT', + element.oxid, + '"' + element[0].className.split(' ').filter(function(className) { + return /^Ox/.test(className); + }).map(function(className) { + return className.replace(/^Ox/, ''); + }).join(' ') + '"', + event, + data, + handlers.length, + handlers.map(function(handler) { + return handler.toString().split('\n').shift(); + }) + ); + } + } /*@ - bind Binds a callback to an event - (event, callback) -> The event handler - ({event: callback, ...}) -> The event handler + .bind Adds an event handler + (callback) -> Ox.Event + (self, callback) -> Ox.Event + (self, event, callback) -> Ox.Event + (self, {event: callback, ...}) -> Ox.Event + self The element's shared private object callback Callback function - data <*> Event data + data Event data + event Event name + element Element event Event name Event names can be namespaced, like `'click.foo'` - @*/ - that.bind = function(self) { - var args = Ox.slice(arguments, 1), once; - if (Ox.isBoolean(Ox.last(args))) { - once = args.pop(); - } - if (Ox.isFunction(args[0])) { - args = {'': args[0]}; - } - Ox.forEach(Ox.makeObject(args), function(callback, event) { - if (once) { - callback.once = true; + */ + that.bind = function() { + var args = Ox.toArray(arguments), once, self; + if (args.length == 1) { + eventHandlers.push(args[0]) + } else { + self = args.shift(); + once = Ox.isBoolean(Ox.last(args)) ? args.pop() : false; + args = Ox.isFunction(args[0]) ? {'*': args[0]} : Ox.makeObject(args); + if (Ox.len(args) && !self.eventHandlers) { + self.eventHandlers = {}; } - self.eventHandlers = self.eventHandlers || {}; - self.eventHandlers[event] = ( - self.eventHandlers[event] || [] - ).concat(callback); - }); + Ox.forEach(args, function(handler, event) { + handler.once = once; + self.eventHandlers[event] = ( + self.eventHandlers[event] || [] + ).concat(handler); + }); + } return that; }; + /*@ + .bindOnce Adds an event handler that fires once + (self, callback) -> Ox.Event + (self, event, callback) -> Ox.Event + (self, {event: callback, ...}) -> Ox.Event + self The element's shared private object + callback Callback function + data Event data + event Event name + element Element + event Event name + Event names can be namespaced, like `'click.foo'` + */ that.bindOnce = function() { return that.bind.apply(null, Ox.slice(arguments).concat(true)); }; - /* + /*@ + .log Turns event logging on or off + (enabled) -> Ox.Event + enabled Enables (`true`) or disables (`false`) event logging + */ + that.log = function(enabled) { + that[enabled ? 'bind' : 'unbind'](log); + return that; + }; + + /*@ + .trigger Triggers an event + (self, event) -> Ox.Event + (self, event, data) -> Ox.Event + (self, {event: data, ...}) -> Ox.Event + self The element's shared private object + event Event name + data Event data */ that.trigger = function(self) { - if (!self.eventHandlers) { - return; - } - Ox.forEach(Ox.makeObject( - Ox.slice(arguments, 1, -1) - ), function(data, event) { - triggered = event.split('.'); - triggered.map(function(v, i) { - return triggered.slice(0, i + 1).join('.'); - }).forEach(function(triggered) { - Ox.forEach( - Ox.extend( - {'': self.eventHandlers[''] || []}, - triggered, self.eventHandlers[triggered] || [] - ), - function(handlers, handled) { + var element = this; + if (self.eventHandlers) { + Ox.forEach(Ox.makeObject( + Ox.slice(arguments, 1) + ), function(data, event) { + var triggered = event.split('.'); + triggered.map(function(v, i) { + return triggered.slice(0, i + 1).join('.'); + }).concat('*').forEach(function(triggered) { + var handlers = self.eventHandlers[triggered]; + handlers && handlers.forEach(function(handler) { handler.once && that.unbind(self, triggered, handler); - handler(data || {}, event, Ox.last(arguments).oxid); - } - ); - }); - }); - return that; - }; - - that.unbind = function(self) { - if (!self.eventHandlers) { - return; - } - var args = Ox.slice(arguments, 1); - if (args.length == 0) { - delete self.eventHandlers; - } else { - if (Ox.isFunction(args[0])) { - args = {'': args[0]}; - } - Ox.forEach(Ox.makeObject(args), function(unbound, event) { - if (!unbound) { - delete self.eventHandlers[event]; - } else { - self.eventHandlers[event].forEach(function(bound, i) { - if (bound == unbound) { - self.eventHandlers[event].splice(i, 1); - } + handler.call(element, data || {}, event); }); - } + }); + eventHandlers.forEach(function(handler) { + handler.call(element, data || {}, event, element); + }); }); } return that; }; /*@ - bindOnce Binds a callback to an event, once - (event, callback) -> The event handler - ({event: callback, ...}) -> The event handler + .unbind Removes an event handler + (callback) -> Ox.Event + (self) -> Ox.Event + (self, callback) -> Ox.Event + (self, event) -> Ox.Event + (self, event, callback) -> Ox.Event + (self, {event: callback, ...}) -> Ox.Event + self The element's shared private object callback Callback function - data <*> Event data event Event name - Event names can be namespaced, like `'click.foo'` - @*/ - that.bindOnce = function() { - Ox.forEach(Ox.makeObject(arguments), function(callback, event) { - self.$eventHandler.one('ox_' + event, function(event, data) { - callback(data.value); - }); - }); - return that; - }; - - /*@ - trigger Triggers an event - (event) -> The event handler - (event, data) -> The event handler - ({event: data, ...}) -> The event handler - event Event name - data <*> Event data - @*/ - that.trigger = function() { - Ox.forEach(Ox.makeObject(arguments), function(data, event) { - Ox.Log('Core', 'Ox.Event.trigger', event, data) - self.$eventHandler.trigger('ox_' + event, {value: data}); - }); - return that; - }; - - /*@ - unbind Unbinds all callbacks from an event - To unbind a specific handler, use namespaced events, like - `bind('click.foo', callback)`, and then `unbind('click.foo')`. - () -> The event handler - Unbinds all events - (event) -> The event handler - Unbinds one event - (event, event, ...) -> The event handler - Unbinds multiple events - ([event, event, ...]) -> The event handler - Unbinds multiple events - event Event name - @*/ + */ that.unbind = function() { - if (arguments.length == 0) { - self.$eventHandler.off(); - } else { - Ox.toArray(arguments).forEach(function(event) { - self.$eventHandler.off('ox_' + event); + var args = Ox.slice(arguments), self; + if (Ox.isFunction(args[0])) { + eventHandlers.forEach(function(handler) { + handler === args[0] && eventHandlers.splice(i, 1); }); + } else if ((self = args.shift()).eventHandlers) { + if (args.length == 0) { + delete self.eventHandlers; + } else { + if (Ox.isFunction(args[0])) { + args = {'*': args[0]}; + } + Ox.forEach(Ox.makeObject(args), function(unbind, event) { + if (Ox.isUndefined(unbind)) { + delete self.eventHandlers[event]; + } else { + self.eventHandlers[event].forEach(function(handler, i) { + handler === unbind && self.eventHandlers[event].splice(i, 1); + }); + } + }); + } } return that; };