[KSS-checkins] r49586 - kukit/kukit.js/branch/finish-closures/kukit
gotcha at codespeak.net
gotcha at codespeak.net
Sun Dec 9 21:37:22 CET 2007
Author: gotcha
Date: Sun Dec 9 21:37:21 2007
New Revision: 49586
Modified:
kukit/kukit.js/branch/finish-closures/kukit/eventreg.js
Log:
class closure
Modified: kukit/kukit.js/branch/finish-closures/kukit/eventreg.js
==============================================================================
--- kukit/kukit.js/branch/finish-closures/kukit/eventreg.js (original)
+++ kukit/kukit.js/branch/finish-closures/kukit/eventreg.js Sun Dec 9 21:37:21 2007
@@ -31,219 +31,222 @@
*
* usage:
*
-* kukit.eventsGlobalRegistry.register(namespace, eventName, func,
+* kukit.eventsGlobalRegistry.register(namespace, eventName, func,
* bindMethodName, defaultActionMethodName);
-*
-* namespace = null: means global namespace
-* defaultActionMethodName = null: if there is no default action implemented
-* func must be a class (constructor) function, this is the class that
-* implements the binder.
+*
+* namespace = null: means global namespace
+* defaultActionMethodName = null: if there is no default action implemented
+* func must be a class (constructor) function, this is the class that
+* implements the binder.
+*
*/
var _EventRegistry = function () {
this.content = {};
this.classes = {};
this.eventSets = [];
-};
/* binder registration */
-_EventRegistry.prototype.registerBinder = function(className, func) {
- if (typeof(func) == 'undefined') {
-;;; kukit.E = 'func argument is mandatory when registering an event';
-;;; kukit.E += ' binder (_EventRegistry.registerBinder).';
- throw new Error(kukit.E);
- }
- if (this.classes[className]) {
- // Do not allow redefinition
-;;; var msg = 'Error : event class [' + className + '] already registered.';
-;;; kukit.logError(msg);
- return;
-
- }
- // Decorate and store the class
- decorateEventBinderClass(func);
- this.classes[className] = func;
-};
+ this.registerBinder = function(className, func) {
+ if (typeof(func) == 'undefined') {
+;;; kukit.E = 'func argument is mandatory when registering an event';
+;;; kukit.E += ' binder (_EventRegistry.registerBinder).';
+ throw new Error(kukit.E);
+ }
+ if (this.classes[className]) {
+ // Do not allow redefinition
+;;; var msg = 'Error : event class [' + className + '] already registered.';
+;;; kukit.logError(msg);
+ return;
+
+ }
+ // Decorate and store the class
+ decorateEventBinderClass(func);
+ this.classes[className] = func;
+ };
+
+ this.existsBinder = function(className) {
+ var func = this.classes[className];
+ return (typeof(func) != 'undefined');
+ };
+
+ this.getBinderClass = function(className) {
+ var func = this.classes[className];
+ if (! func) {
+ // not found
+;;; kukit.E = 'Error : undefined event setup type [' + className + '].';
+ throw new Error(kukit.E);
+ }
+ return func;
+ };
-_EventRegistry.prototype.existsBinder = function(className) {
- var func = this.classes[className];
- return (typeof(func) != 'undefined');
-};
+ /* events (methods) registration helpers (not to be called directly) */
-_EventRegistry.prototype.getBinderClass = function(className) {
- var func = this.classes[className];
- if (! func) {
- // not found
-;;; kukit.E = 'Error : undefined event setup type [' + className + '].';
- throw new Error(kukit.E);
+ this._register =
+ function(namespace, eventName, klass,
+ bindMethodName, defaultActionMethodName, iterName) {
+ if (typeof(defaultActionMethodName) == 'undefined') {
+;;; kukit.E = 'Missing arguments when calling [_EventRegistry.register].';
+ throw new Error(kukit.E);
}
- return func;
-};
+ // Find out the class name. (Not specified now.)
+ var className = klass.prototype.__className__;
+ if (typeof(className) == 'undefined') {
+ // Create a className, and register it too.
+ className = '' + _eventClassCounter;
+ _eventClassCounter += 1;
+ this.registerBinder(className, klass);
+ klass.prototype.__className__ = className;
+ }
+ if (!eventName) {
+;;; kukit.E = '[eventName] argument cannot be empty when registering';
+;;; kukit.E += ' an event with [_EventRegistry.register].';
+ throw new Error(kukit.E);
+ }
+ var key = this._getKey(namespace, eventName);
+ var entry = this.content[key];
+ if (typeof(entry) != 'undefined') {
+ if (key[0] == '-') {
+ key = key.substring(1);
+ }
+;;; kukit.E = 'Attempt to register key [' + key;
+;;; kukit.E += '] twice when registering';
+;;; kukit.E += ' an event with [_EventRegistry.register].';
+ throw new Error(kukit.E);
+ }
+ // check bindMethodName and defaultActionMethodName
+ if (bindMethodName && ! klass.prototype[bindMethodName]) {
+;;; kukit.E = 'In _EventRegistry.register bind method [' + bindMethodName;
+;;; kukit.E += '] is undefined for event [' + eventName;
+;;; kukit.E += '] namespace [' + namespace + '].';
+ throw new Error(kukit.E);
+ }
+ if (defaultActionMethodName && ! klass.prototype[defaultActionMethodName]) {
+;;; kukit.E = 'In _EventRegistry.register default action method [';
+;;; kukit.E += defaultActionMethodName + '] is undefined for event [';
+;;; kukit.E += eventName + '] namespace [' + namespace + '].';
+ throw new Error(kukit.E);
+ }
+ // check the iterator.
+ if (! er.getBindIterator(iterName)) {
+;;; kukit.E = 'In _EventRegistry.register unknown bind iterator [';
+;;; kukit.E += iterName + '].';
+ throw new Error(kukit.E);
+ }
+ // register it
+ this.content[key] = {
+ 'className': className,
+ 'bindMethodName': bindMethodName,
+ 'defaultActionMethodName': defaultActionMethodName,
+ 'iterName': iterName
+ };
+ };
-/* events (methods) registration helpers (not to be called directly) */
+ /* events (methods) binding [ForAll] registration */
-_EventRegistry.prototype._register =
- function(namespace, eventName, klass,
- bindMethodName, defaultActionMethodName, iterName) {
- if (typeof(defaultActionMethodName) == 'undefined') {
-;;; kukit.E = 'Missing arguments when calling [_EventRegistry.register].';
- throw new Error(kukit.E);
- }
- // Find out the class name. (Not specified now.)
- var className = klass.prototype.__className__;
- if (typeof(className) == 'undefined') {
- // Create a className, and register it too.
- className = '' + _eventClassCounter;
- _eventClassCounter += 1;
- this.registerBinder(className, klass);
- klass.prototype.__className__ = className;
- }
- if (!eventName) {
-;;; kukit.E = '[eventName] argument cannot be empty when registering';
-;;; kukit.E += ' an event with [_EventRegistry.register].';
- throw new Error(kukit.E);
- }
- var key = this._getKey(namespace, eventName);
- var entry = this.content[key];
- if (typeof(entry) != 'undefined') {
- if (key[0] == '-') {
- key = key.substring(1);
- }
-;;; kukit.E = 'Attempt to register key [' + key;
-;;; kukit.E += '] twice when registering';
-;;; kukit.E += ' an event with [_EventRegistry.register].';
- throw new Error(kukit.E);
- }
- // check bindMethodName and defaultActionMethodName
- if (bindMethodName && ! klass.prototype[bindMethodName]) {
-;;; kukit.E = 'In _EventRegistry.register bind method [' + bindMethodName;
-;;; kukit.E += '] is undefined for event [' + eventName;
-;;; kukit.E += '] namespace [' + namespace + '].';
- throw new Error(kukit.E);
- }
- if (defaultActionMethodName && ! klass.prototype[defaultActionMethodName]) {
-;;; kukit.E = 'In _EventRegistry.register default action method [';
-;;; kukit.E += defaultActionMethodName + '] is undefined for event [';
-;;; kukit.E += eventName + '] namespace [' + namespace + '].';
- throw new Error(kukit.E);
- }
- // check the iterator.
- if (! er.getBindIterator(iterName)) {
-;;; kukit.E = 'In _EventRegistry.register unknown bind iterator [';
-;;; kukit.E += iterName + '].';
- throw new Error(kukit.E);
- }
- // register it
- this.content[key] = {
- 'className': className,
- 'bindMethodName': bindMethodName,
- 'defaultActionMethodName': defaultActionMethodName,
- 'iterName': iterName
- };
-};
-
-/* events (methods) binding [ForAll] registration */
-
-_EventRegistry.prototype._registerEventSet =
- function(namespace, names, iterName, bindMethodName) {
- // At this name the values should be checked already. so this should
- // be called _after_ _register.
- this.eventSets.push({
- 'namespace': namespace,
- 'names': names,
- 'iterName': iterName,
- 'bindMethodName': bindMethodName
- });
-};
-
-/* there are the actual registration methods, to be called from plugins */
-
-_EventRegistry.prototype.register =
- function(namespace, eventName, klass, bindMethodName,
- defaultActionMethodName) {
- this._register(namespace, eventName, klass, bindMethodName,
- defaultActionMethodName, 'EachLegacy');
- this._registerEventSet(namespace, [eventName], 'EachLegacy',
- bindMethodName);
-};
-
-_EventRegistry.prototype.unregister =
- function(namespace, eventName) {
- var key = this._getKey(namespace, eventName);
- delete this.content[key];
- var found = null;
- for (var i=0; i < this.eventSets.length; i++) {
- var eventSet = this.eventSets[i];
- if (eventSet['namespace'] == namespace) {
- found = i;
- break;
+ this._registerEventSet =
+ function(namespace, names, iterName, bindMethodName) {
+ // At this name the values should be checked already. so this should
+ // be called _after_ _register.
+ this.eventSets.push({
+ 'namespace': namespace,
+ 'names': names,
+ 'iterName': iterName,
+ 'bindMethodName': bindMethodName
+ });
+ };
+
+ /* there are the actual registration methods, to be called from plugins */
+
+ this.register =
+ function(namespace, eventName, klass, bindMethodName,
+ defaultActionMethodName) {
+ this._register(namespace, eventName, klass, bindMethodName,
+ defaultActionMethodName, 'EachLegacy');
+ this._registerEventSet(namespace, [eventName], 'EachLegacy',
+ bindMethodName);
+ };
+
+ this.unregister =
+ function(namespace, eventName) {
+ var key = this._getKey(namespace, eventName);
+ delete this.content[key];
+ var found = null;
+ for (var i=0; i < this.eventSets.length; i++) {
+ var eventSet = this.eventSets[i];
+ if (eventSet['namespace'] == namespace) {
+ found = i;
+ break;
+ }
}
- }
- if (found != null) {
- this.eventSets.splice(found, 1);
- }
-};
+ if (found != null) {
+ this.eventSets.splice(found, 1);
+ }
+ };
-_EventRegistry.prototype.registerForAllEvents =
- function(namespace, eventNames, klass,
- bindMethodName, defaultActionMethodName, iterName) {
- if (typeof(eventNames) == 'string') {
- eventNames = [eventNames];
- }
- for (var i=0; i<eventNames.length; i++) {
- var eventName = eventNames[i];
- this._register(namespace, eventName, klass, bindMethodName,
- defaultActionMethodName, iterName);
- }
- this._registerEventSet(namespace, eventNames, iterName, bindMethodName);
-};
+ this.registerForAllEvents =
+ function(namespace, eventNames, klass,
+ bindMethodName, defaultActionMethodName, iterName) {
+ if (typeof(eventNames) == 'string') {
+ eventNames = [eventNames];
+ }
+ for (var i=0; i<eventNames.length; i++) {
+ var eventName = eventNames[i];
+ this._register(namespace, eventName, klass, bindMethodName,
+ defaultActionMethodName, iterName);
+ }
+ this._registerEventSet(namespace, eventNames, iterName, bindMethodName);
+ };
+
+ this._getKey = function(namespace, eventName) {
+ if (namespace == null) {
+ namespace = '';
+ } else if (namespace.split('-') > 1) {
+;;; kukit.E = 'In [_EventRegistry.register], [namespace] cannot have';
+;;; kukit.E += 'dashes.';
+ throw new Error(kukit.E);
+ }
+ return namespace + '-' + eventName;
+ };
-_EventRegistry.prototype._getKey = function(namespace, eventName) {
- if (namespace == null) {
- namespace = '';
- } else if (namespace.split('-') > 1) {
-;;; kukit.E = 'In [_EventRegistry.register], [namespace] cannot have';
-;;; kukit.E += 'dashes.';
- throw new Error(kukit.E);
- }
- return namespace + '-' + eventName;
+ this.exists = function(namespace, eventName) {
+ var key = this._getKey(namespace, eventName);
+ var entry = this.content[key];
+ return (typeof(entry) != 'undefined');
+ };
+
+ this.get = function(namespace, eventName) {
+ var key = this._getKey(namespace, eventName);
+ var entry = this.content[key];
+ if (typeof(entry) == 'undefined') {
+;;; if (key.substr(0, 1) == '-') {
+;;; key = key.substring(1);
+;;; kukit.E = 'Error : undefined global event [';
+;;; kukit.E += key + '] (or maybe namespace is missing ?).';
+;;; } else {
+;;; kukit.E = 'Error : undefined namespace or event in [' + key + '].';
+;;; }
+ throw new Error(kukit.E);
+ }
+ return entry;
+ };
};
-_EventRegistry.prototype.exists = function(namespace, eventName) {
- var key = this._getKey(namespace, eventName);
- var entry = this.content[key];
- return (typeof(entry) != 'undefined');
-};
-
-_EventRegistry.prototype.get = function(namespace, eventName) {
- var key = this._getKey(namespace, eventName);
- var entry = this.content[key];
- if (typeof(entry) == 'undefined') {
-;;; if (key.substr(0, 1) == '-') {
-;;; key = key.substring(1);
-;;; kukit.E = 'Error : undefined global event [';
-;;; kukit.E += key + '] (or maybe namespace is missing ?).';
-;;; } else {
-;;; kukit.E = 'Error : undefined namespace or event in [' + key + '].';
-;;; }
- throw new Error(kukit.E);
- }
- return entry;
-};
kukit.eventsGlobalRegistry = new _EventRegistry();
/* XXX deprecated methods, to be removed asap */
-var _eventRegistry = {};
-_eventRegistry.register = function(namespace, eventName, klass,
- bindMethodName, defaultActionMethodName) {
-;;; var msg = 'Deprecated _eventRegistry.register,';
-;;; msg += ' use kukit.eventsGlobalRegistry.register instead ! [';
-;;; msg += namespace + '-' + eventName + '].';
-;;; kukit.logWarning(msg);
- kukit.eventsGlobalRegistry.register(namespace, eventName, klass,
- bindMethodName, defaultActionMethodName);
+var _eventRegistry = function() {
+ this.register = function(namespace, eventName, klass,
+ bindMethodName, defaultActionMethodName) {
+;;; var msg = 'Deprecated _eventRegistry.register,';
+;;; msg += ' use kukit.eventsGlobalRegistry.register instead ! [';
+;;; msg += namespace + '-' + eventName + '].';
+;;; kukit.logWarning(msg);
+ kukit.eventsGlobalRegistry.register(namespace, eventName, klass,
+ bindMethodName, defaultActionMethodName);
+ };
};
/* Event class decoration
@@ -408,34 +411,34 @@
this.name = name;
this.node = node;
this.boundEvent = null;
-};
-_LateBinder.prototype.executeActions = function() {
- if (! this.boundEvent) {
-;;; var msg = 'Attempt of late binding for event [' + this.name;
-;;; msg += '], node [' + this.node.nodeName + '].';
-;;; kukit.log(msg);
- if (kukit.hasFirebug) {
- kukit.log(this.node);
- }
- var info = kukit.engine.binderInfoRegistry.getBinderInfoById(
- this.binder.__binderId__);
- var oper = info.bound.getBoundOperForNode(this.name, this.node);
- if (oper) {
- // (if eventRule is null here, we could still have the default
- // method, so go on.)
- oper.parms = {};
- this.boundEvent = function() {
- this.binder._EventBinder_triggerEvent(this.name, oper);
- };
-;;; kukit.log('Node bound.');
- } else {
-;;; kukit.logWarning('No node bound.');
- this.boundEvent = function() {};
+ this.executeActions = function() {
+ if (! this.boundEvent) {
+;;; var msg = 'Attempt of late binding for event [' + this.name;
+;;; msg += '], node [' + this.node.nodeName + '].';
+;;; kukit.log(msg);
+ if (kukit.hasFirebug) {
+ kukit.log(this.node);
+ }
+ var info = kukit.engine.binderInfoRegistry.getBinderInfoById(
+ this.binder.__binderId__);
+ var oper = info.bound.getBoundOperForNode(this.name, this.node);
+ if (oper) {
+ // (if eventRule is null here, we could still have the default
+ // method, so go on.)
+ oper.parms = {};
+ this.boundEvent = function() {
+ this.binder._EventBinder_triggerEvent(this.name, oper);
+ };
+;;; kukit.log('Node bound.');
+ } else {
+;;; kukit.logWarning('No node bound.');
+ this.boundEvent = function() {};
+ }
}
- }
- this.boundEvent();
-};
+ this.boundEvent();
+ };
+};
var _EventBinder_triggerEvent = function(name, oper) {
// Private. Called from __continueEvent__ or from main event execution.
@@ -499,82 +502,82 @@
er.BinderInfoRegistry = function () {
this.info = {};
-};
-
-er.BinderInfoRegistry.prototype.getOrCreateBinderInfo =
- function (id, className, namespace) {
- // Get or create the event.
- var binderInfo = this.info[id];
- if (typeof(binderInfo) == 'undefined') {
- // Create a new event.
-;;; var msg = 'Instantiating event id [' + id + '], className [';
-;;; msg += className + '], namespace [' + namespace + '].';
-;;; kukit.logDebug(msg);
- var binderClass = kukit.eventsGlobalRegistry.getBinderClass(className);
- var binder = new binderClass();
-
- binderInfo = this.info[id] = new _BinderInfo(binder);
-
- // decorate it with id and class
- binder.__binderId__ = id;
- binder.__binderClassName__ = className;
- binder.__eventNamespace__ = namespace;
- // store the bound rules
- //binder.__bound_rules__ = [];
- } else if (binderInfo.getBinder().__binderClassName__ !=
- className) {
- // just paranoia
-;;; kukit.E = 'Conflicting class for event id [' + id + '], [';
-;;; kukit.E += binderInfo.getBinder().__binderClassName__;
-;;; kukit.E += '] != [' + className + '].';
- throw new Error(kukit.E);
- }
- return binderInfo;
-};
-er.BinderInfoRegistry.prototype.getBinderInfoById = function (id) {
- // Get an event.
- var binderInfo = this.info[id];
- if (typeof(binderInfo) == 'undefined') {
-;;; kukit.E = 'Event with id [' + id + '] not found.';
- throw new Error(kukit.E);
- }
- return binderInfo;
-};
-
-er.BinderInfoRegistry.prototype.getSingletonBinderInfoByName =
- function (namespace, name) {
- //Get className
- var className = kukit.eventsGlobalRegistry.get(namespace, name).className;
- // Get an event.
- var id = er.makeId(namespace, className);
- var binderInfo = this.info[id];
- if (typeof(binderInfo) == 'undefined') {
-;;; kukit.E = 'Singleton event with namespace [' + namespace;
-;;; kukit.E += '] and (event) name [' + name + '] not found.';
- throw new Error(kukit.E);
- }
- return binderInfo;
-};
+ this.getOrCreateBinderInfo =
+ function (id, className, namespace) {
+ // Get or create the event.
+ var binderInfo = this.info[id];
+ if (typeof(binderInfo) == 'undefined') {
+ // Create a new event.
+;;; var msg = 'Instantiating event id [' + id + '], className [';
+;;; msg += className + '], namespace [' + namespace + '].';
+;;; kukit.logDebug(msg);
+ var binderClass = kukit.eventsGlobalRegistry.getBinderClass(className);
+ var binder = new binderClass();
+
+ binderInfo = this.info[id] = new _BinderInfo(binder);
+
+ // decorate it with id and class
+ binder.__binderId__ = id;
+ binder.__binderClassName__ = className;
+ binder.__eventNamespace__ = namespace;
+ // store the bound rules
+ //binder.__bound_rules__ = [];
+ } else if (binderInfo.getBinder().__binderClassName__ !=
+ className) {
+ // just paranoia
+;;; kukit.E = 'Conflicting class for event id [' + id + '], [';
+;;; kukit.E += binderInfo.getBinder().__binderClassName__;
+;;; kukit.E += '] != [' + className + '].';
+ throw new Error(kukit.E);
+ }
+ return binderInfo;
+ };
-er.BinderInfoRegistry.prototype.startBindingPhase = function () {
- // At the end of the binding phase, we want to process our events. This
- // must include all the binder instances we bound in this phase.
- for (var id in this.info) {
+ this.getBinderInfoById = function (id) {
+ // Get an event.
var binderInfo = this.info[id];
- // process binding on this instance.
- binderInfo.startBindingPhase();
- }
-};
+ if (typeof(binderInfo) == 'undefined') {
+;;; kukit.E = 'Event with id [' + id + '] not found.';
+ throw new Error(kukit.E);
+ }
+ return binderInfo;
+ };
-er.BinderInfoRegistry.prototype.processBindingEvents = function () {
- // At the end of the binding phase, we want to process our events. This
- // must include all the binder instances we bound in this phase.
- for (var id in this.info) {
+ this.getSingletonBinderInfoByName =
+ function (namespace, name) {
+ //Get className
+ var className = kukit.eventsGlobalRegistry.get(namespace, name).className;
+ // Get an event.
+ var id = er.makeId(namespace, className);
var binderInfo = this.info[id];
- // process binding on this instance.
- binderInfo.processBindingEvents();
- }
+ if (typeof(binderInfo) == 'undefined') {
+;;; kukit.E = 'Singleton event with namespace [' + namespace;
+;;; kukit.E += '] and (event) name [' + name + '] not found.';
+ throw new Error(kukit.E);
+ }
+ return binderInfo;
+ };
+
+ this.startBindingPhase = function () {
+ // At the end of the binding phase, we want to process our events. This
+ // must include all the binder instances we bound in this phase.
+ for (var id in this.info) {
+ var binderInfo = this.info[id];
+ // process binding on this instance.
+ binderInfo.startBindingPhase();
+ }
+ };
+
+ this.processBindingEvents = function () {
+ // At the end of the binding phase, we want to process our events. This
+ // must include all the binder instances we bound in this phase.
+ for (var id in this.info) {
+ var binderInfo = this.info[id];
+ // process binding on this instance.
+ binderInfo.processBindingEvents();
+ }
+ };
};
/*
@@ -588,163 +591,153 @@
var _BinderInfo = function (binder) {
this.binder = binder;
this.bound = new _OperRegistry();
- this.startBindingPhase();
-};
-
-_BinderInfo.prototype.getBinder = function () {
- return this.binder;
-};
-_BinderInfo.prototype.startBindingPhase = function () {
- // The binding phase starts and it has the information for
- // the currently on-bound events.
- this.binding = new _OperRegistry();
-};
+ this.getBinder = function () {
+ return this.binder;
+ };
+
+ this.startBindingPhase = function () {
+ // The binding phase starts and it has the information for
+ // the currently on-bound events.
+ this.binding = new _OperRegistry();
+ };
+
+ this.bindOper = function (oper) {
+ // We mark a given oper. This means a binding on the binder
+ // for given event, node and eventRule (containing event namespace,
+ // name, and evt- parms.)
+ //
+ // first see if it can go to already bound ones
+ this.bound.checkOperBindable(oper);
+ // then register it properly to the binding events
+ this.binding.bindOper(oper);
+ };
+
+ this.processBindingEvents = function () {
+ // We came to the end of the binding phase. Now we process all our binding
+ // events, This will do the actual binding on the browser side.
+ this.binding.processBindingEvents(this.binder);
+ // Now we to add these to the new ones.
+ this.binding.propagateTo(this.bound);
+ // Delete them from the registry, to protect against accidents.
+ this.binding = null;
+ };
-_BinderInfo.prototype.bindOper = function (oper) {
- // We mark a given oper. This means a binding on the binder
- // for given event, node and eventRule (containing event namespace,
- // name, and evt- parms.)
- //
- // first see if it can go to already bound ones
- this.bound.checkOperBindable(oper);
- // then register it properly to the binding events
- this.binding.bindOper(oper);
-};
-
-_BinderInfo.prototype.processBindingEvents = function () {
- // We came to the end of the binding phase. Now we process all our binding
- // events, This will do the actual binding on the browser side.
- this.binding.processBindingEvents(this.binder);
- // Now we to add these to the new ones.
- this.binding.propagateTo(this.bound);
- // Delete them from the registry, to protect against accidents.
- this.binding = null;
+ this.startBindingPhase();
};
+var _iterators = {};
-/*
-* class _OperRegistry
-*
-* OperRegistry is associated with a binder instance in the
-* BinderInfoRegistry, and remembers bounding information.
-* This is used both to remember all the bindings for a given
-* instance, but also just to remember the bindings done during
-* a given event setup phase.
-*/
-
-var _OperRegistry = function () {
- this.infoPerName = {};
- this.infoPerNode = {};
-};
-
-// XXX we can do this without full cloning, more efficiently.
-_OperRegistry.prototype.propagateTo = function (newreg) {
- for (var key in this.infoPerName) {
- var rulesPerName = this.infoPerName[key];
- for (var name in rulesPerName) {
- var oper = rulesPerName[name];
- newreg.bindOper(oper);
+ // This calls the bind method by each bound oper one by one.
+ // Eventname and funcToBind are passed too.
+ // this is the legacy ([EachLegacy]) way
+ _iterators['EachLegacy'] =
+ function (eventSet, binder) {
+ for (var i=0; i<eventSet.names.length; i++) {
+ var rulesPerName = this.infoPerName[eventSet.names[i]];
+ if (typeof(rulesPerName) != 'undefined') {
+ for (var nodeHash in rulesPerName) {
+ var oper = rulesPerName[nodeHash];
+ var eventName = oper.getEventName();
+ var funcToBind = oper.makeExecuteActionsHook();
+ this.callBindMethod(eventSet, binder, eventName,
+ funcToBind, oper);
+ }
+ }
}
- }
-};
-
-_OperRegistry.prototype.checkOperBindable =
- function (oper, name, nodeHash) {
- // Check if the binding with this oper could be done.
- // Throw exception otherwise.
- //
- // Remark. We need different check and bind method,
- // because we need to bind to the currently
- // processed nodes, but we need to check duplication
- // in all the previously bound nodes.
- var info = this.infoPerName;
- // name and nodeHash are for speedup.
- if (typeof(nodeHash) == 'undefined') {
- name = oper.eventRule.kssSelector.name;
- nodeHash = kukit.rd.hashNode(oper.node);
- }
- var rulesPerName = info[name];
- if (typeof(rulesPerName) == 'undefined') {
- // Create an empty list.
- rulesPerName = info[name] = {};
- } else if (typeof(rulesPerName[nodeHash]) != 'undefined') {
-;;; kukit.E = 'Mismatch in bind registry,[ ' + name;
-;;; kukit.E += '] already bound to node in this instance.';
- throw new Error(kukit.E);
- }
- return rulesPerName;
-};
-
-_OperRegistry.prototype.bindOper = function (oper) {
- // Marks binding between binder, eventName, node.
- var name = oper.eventRule.kssSelector.name;
- var nodeHash = kukit.rd.hashNode(oper.node);
- var rulesPerName = this.checkOperBindable(oper, name, nodeHash);
- rulesPerName[nodeHash] = oper;
- // also store per node info
- var rulesPerNode = this.infoPerNode[nodeHash];
- if (typeof(rulesPerNode) == 'undefined') {
- // Create an empty list.
- rulesPerNode = this.infoPerNode[nodeHash] = {};
- }
- rulesPerNode[name] = oper;
-};
+ };
-// XXX This will need refactoring.
-/// We would only want to lookup from our registry and not the other way around.
-_OperRegistry.prototype.processBindingEvents =
- function (binder) {
- var eventRegistry = kukit.eventsGlobalRegistry;
- for (var i=0; i < eventRegistry.eventSets.length; i++) {
- var eventSet = eventRegistry.eventSets[i];
- // Only process binding events (and ignore non-binding ones)
- if (eventSet.bindMethodName) {
- if (binder.__eventNamespace__ == eventSet.namespace) {
- // Process the binding event set.
- // This will call the actual bindmethods
- // according to the specified iterator.
- var iterator = er.getBindIterator(eventSet.iterName);
- iterator.call(this, eventSet, binder);
+ // This calls the bind method by each bound oper one by one.
+ // Eventname and funcToBind are passed too.
+ // this is the preferred ([Each]) way. Parameters are different from EachLegacy.
+ _iterators['Each'] =
+ function (eventSet, binder) {
+ for (var i=0; i<eventSet.names.length; i++) {
+ var rulesPerName = this.infoPerName[eventSet.names[i]];
+ if (typeof(rulesPerName) != 'undefined') {
+ for (var nodeHash in rulesPerName) {
+ var oper = rulesPerName[nodeHash];
+ this.callBindMethod(eventSet, binder, oper);
+ }
}
}
- }
-};
+ };
-// XXX The following methods will probably disappear as iterators
-// replace their functionality.
+ // This calls the bind method by the list of bound opers
+ _iterators['Opers'] =
+ function (eventSet, binder) {
+ var opers = [];
+ for (var i=0; i<eventSet.names.length; i++) {
+ var rulesPerName = this.infoPerName[eventSet.names[i]];
+ if (typeof(rulesPerName) != 'undefined') {
+ for (var nodeHash in rulesPerName) {
+ opers.push(rulesPerName[nodeHash]);
+ }
+ }
+ }
+ this.callBindMethod(eventSet, binder, opers);
+ };
-_OperRegistry.prototype.getBoundOperForNode = function (name, node) {
- // Get the oper that is bound to a given eventName
- // to a node in this binder
- // returns null, if there is no such oper.
- var rulesPerName = this.infoPerName[name];
- if (typeof(rulesPerName) == 'undefined') {
- return null;
- }
- var nodeHash = kukit.rd.hashNode(node);
- var oper = rulesPerName[nodeHash];
- if (typeof(oper) == 'undefined') {
- return null;
- }
- // Return it
- return oper;
-};
+ // This calls the bind method by a mapping eventName:oper
+ // per each bound node individually
+ _iterators['Node'] =
+ function (eventSet, binder) {
+ for (var nodeHash in this.infoPerNode) {
+ var rulesPerNode = this.infoPerNode[nodeHash];
+ // filter only the events we are interested in
+ var filteredRules = {};
+ var operFound = false;
+ for (var i=0; i<eventSet.names.length; i++) {
+ var name = eventSet.names[i];
+ var oper = rulesPerNode[name];
+ if (typeof(oper) != 'undefined') {
+ filteredRules[name] = oper;
+ operFound = oper;
+ }
+ }
+ // call it
+ // All opers have the same node, the last one is yet in operFound, so
+ // we use it as a second parameter to the call.
+ // The method may or may not want to use this.
+ if (operFound) {
+ this.callBindMethod(eventSet, binder, filteredRules,
+ operFound.node);
+ }
+ }
+ };
-_OperRegistry.prototype.getBoundOpers = function (name) {
- // Get the opers bound to a given eventName (to any node)
- // in this binder
- var opers = [];
- var rulesPerName = this.infoPerName[name];
- if (typeof(rulesPerName) != 'undefined') {
- // take the values as a list
- for (var nodeHash in rulesPerName) {
- opers.push(rulesPerName[nodeHash]);
+ // This calls the bind method once per instance, by a list of
+ // items, where item.node is the node and item.opersByEventName nodeHash:item
+ // in item there is item.node and item.opersByEventName
+ _iterators['AllNodes'] =
+ function (eventSet, binder) {
+ var items = [];
+ var hasResult = false;
+ for (var nodeHash in this.infoPerNode) {
+ var rulesPerNode = this.infoPerNode[nodeHash];
+ // filter only the events we are interested in
+ var filteredRules = {};
+ var operFound = false;
+ for (var i=0; i<eventSet.names.length; i++) {
+ var name = eventSet.names[i];
+ var oper = rulesPerNode[name];
+ if (typeof(oper) != 'undefined') {
+ filteredRules[name] = oper;
+ operFound = oper;
+ }
+ }
+ if (operFound) {
+ var item = {node: operFound.node,
+ opersByEventName: filteredRules};
+ items.push(item);
+ hasResult = true;
+ }
}
- }
- // Return it
- return opers;
-};
+ // call the binder method
+ if (hasResult) {
+ this.callBindMethod(eventSet, binder, items);
+ }
+ };
// Iterators
// The getBindIterator returns a function that gets executed on
@@ -776,133 +769,147 @@
;;; kukit.logWarning(msg);
iterName = canonical;
}
- return _OperRegistry.prototype['_iterate' + iterName];
+ return _iterators[iterName];
};
-_OperRegistry.prototype.callBindMethod =
- function (eventSet, binder, p1, p2, p3, p4, p5, p6) {
- var method = binder[eventSet.bindMethodName];
- // Protect the binding for better logging
-;;; try {
- method.call(binder, p1, p2, p3, p4, p5, p6);
-;;; } catch(e) {
-;;; var names = eventSet.names;
-;;; var namespace = eventSet.namespace;
-;;; kukit.E = kukit.err.eventBindError(e, names, namespace);
-;;; throw new Error(kukit.E);
-;;; }
-};
-
-// This calls the bind method by each bound oper one by one.
-// Eventname and funcToBind are passed too.
-// this is the legacy ([EachLegacy]) way
-_OperRegistry.prototype._iterateEachLegacy =
- function (eventSet, binder) {
- for (var i=0; i<eventSet.names.length; i++) {
- var rulesPerName = this.infoPerName[eventSet.names[i]];
- if (typeof(rulesPerName) != 'undefined') {
- for (var nodeHash in rulesPerName) {
- var oper = rulesPerName[nodeHash];
- var eventName = oper.getEventName();
- var funcToBind = oper.makeExecuteActionsHook();
- this.callBindMethod(eventSet, binder, eventName,
- funcToBind, oper);
+/*
+* class _OperRegistry
+*
+* OperRegistry is associated with a binder instance in the
+* BinderInfoRegistry, and remembers bounding information.
+* This is used both to remember all the bindings for a given
+* instance, but also just to remember the bindings done during
+* a given event setup phase.
+*
+*/
+var _OperRegistry = function () {
+ this.infoPerName = {};
+ this.infoPerNode = {};
+
+ // XXX we can do this without full cloning, more efficiently.
+ this.propagateTo = function (newreg) {
+ for (var key in this.infoPerName) {
+ var rulesPerName = this.infoPerName[key];
+ for (var name in rulesPerName) {
+ var oper = rulesPerName[name];
+ newreg.bindOper(oper);
}
}
- }
-};
+ };
-
-// This calls the bind method by each bound oper one by one.
-// Eventname and funcToBind are passed too.
-// this is the preferred ([Each]) way. Parameters are different from EachLegacy.
-_OperRegistry.prototype._iterateEach =
- function (eventSet, binder) {
- for (var i=0; i<eventSet.names.length; i++) {
- var rulesPerName = this.infoPerName[eventSet.names[i]];
- if (typeof(rulesPerName) != 'undefined') {
- for (var nodeHash in rulesPerName) {
- var oper = rulesPerName[nodeHash];
- this.callBindMethod(eventSet, binder, oper);
+ this.checkOperBindable =
+ function (oper, name, nodeHash) {
+ // Check if the binding with this oper could be done.
+ // Throw exception otherwise.
+ //
+ // Remark. We need different check and bind method,
+ // because we need to bind to the currently
+ // processed nodes, but we need to check duplication
+ // in all the previously bound nodes.
+ var info = this.infoPerName;
+ // name and nodeHash are for speedup.
+ if (typeof(nodeHash) == 'undefined') {
+ name = oper.eventRule.kssSelector.name;
+ nodeHash = kukit.rd.hashNode(oper.node);
+ }
+ var rulesPerName = info[name];
+ if (typeof(rulesPerName) == 'undefined') {
+ // Create an empty list.
+ rulesPerName = info[name] = {};
+ } else if (typeof(rulesPerName[nodeHash]) != 'undefined') {
+;;; kukit.E = 'Mismatch in bind registry,[ ' + name;
+;;; kukit.E += '] already bound to node in this instance.';
+ throw new Error(kukit.E);
+ }
+ return rulesPerName;
+ };
+
+ this.bindOper = function (oper) {
+ // Marks binding between binder, eventName, node.
+ var name = oper.eventRule.kssSelector.name;
+ var nodeHash = kukit.rd.hashNode(oper.node);
+ var rulesPerName = this.checkOperBindable(oper, name, nodeHash);
+ rulesPerName[nodeHash] = oper;
+ // also store per node info
+ var rulesPerNode = this.infoPerNode[nodeHash];
+ if (typeof(rulesPerNode) == 'undefined') {
+ // Create an empty list.
+ rulesPerNode = this.infoPerNode[nodeHash] = {};
+ }
+ rulesPerNode[name] = oper;
+ };
+
+ // XXX This will need refactoring.
+ /// We would only want to lookup from our registry and not the other way around.
+ this.processBindingEvents =
+ function (binder) {
+ var eventRegistry = kukit.eventsGlobalRegistry;
+ for (var i=0; i < eventRegistry.eventSets.length; i++) {
+ var eventSet = eventRegistry.eventSets[i];
+ // Only process binding events (and ignore non-binding ones)
+ if (eventSet.bindMethodName) {
+ if (binder.__eventNamespace__ == eventSet.namespace) {
+ // Process the binding event set.
+ // This will call the actual bindmethods
+ // according to the specified iterator.
+ var iterator = er.getBindIterator(eventSet.iterName);
+ iterator.call(this, eventSet, binder);
+ }
}
}
- }
-};
+ };
+
+ // XXX The following methods will probably disappear as iterators
+ // replace their functionality.
-// This calls the bind method by the list of bound opers
-_OperRegistry.prototype._iterateOpers =
- function (eventSet, binder) {
- var opers = [];
- for (var i=0; i<eventSet.names.length; i++) {
- var rulesPerName = this.infoPerName[eventSet.names[i]];
+ this.getBoundOperForNode = function (name, node) {
+ // Get the oper that is bound to a given eventName
+ // to a node in this binder
+ // returns null, if there is no such oper.
+ var rulesPerName = this.infoPerName[name];
+ if (typeof(rulesPerName) == 'undefined') {
+ return null;
+ }
+ var nodeHash = kukit.rd.hashNode(node);
+ var oper = rulesPerName[nodeHash];
+ if (typeof(oper) == 'undefined') {
+ return null;
+ }
+ // Return it
+ return oper;
+ };
+
+ this.getBoundOpers = function (name) {
+ // Get the opers bound to a given eventName (to any node)
+ // in this binder
+ var opers = [];
+ var rulesPerName = this.infoPerName[name];
if (typeof(rulesPerName) != 'undefined') {
+ // take the values as a list
for (var nodeHash in rulesPerName) {
opers.push(rulesPerName[nodeHash]);
}
}
- }
- this.callBindMethod(eventSet, binder, opers);
-};
+ // Return it
+ return opers;
+ };
+
+
+ this.callBindMethod =
+ function (eventSet, binder, p1, p2, p3, p4, p5, p6) {
+ var method = binder[eventSet.bindMethodName];
+ // Protect the binding for better logging
+;;; try {
+ method.call(binder, p1, p2, p3, p4, p5, p6);
+;;; } catch(e) {
+;;; var names = eventSet.names;
+;;; var namespace = eventSet.namespace;
+;;; kukit.E = kukit.err.eventBindError(e, names, namespace);
+;;; throw new Error(kukit.E);
+;;; }
+ };
-// This calls the bind method by a mapping eventName:oper
-// per each bound node individually
-_OperRegistry.prototype._iterateNode =
- function (eventSet, binder) {
- for (var nodeHash in this.infoPerNode) {
- var rulesPerNode = this.infoPerNode[nodeHash];
- // filter only the events we are interested in
- var filteredRules = {};
- var operFound = false;
- for (var i=0; i<eventSet.names.length; i++) {
- var name = eventSet.names[i];
- var oper = rulesPerNode[name];
- if (typeof(oper) != 'undefined') {
- filteredRules[name] = oper;
- operFound = oper;
- }
- }
- // call it
- // All opers have the same node, the last one is yet in operFound, so
- // we use it as a second parameter to the call.
- // The method may or may not want to use this.
- if (operFound) {
- this.callBindMethod(eventSet, binder, filteredRules,
- operFound.node);
- }
- }
-};
-// This calls the bind method once per instance, by a list of
-// items, where item.node is the node and item.opersByEventName nodeHash:item
-// in item there is item.node and item.opersByEventName
-_OperRegistry.prototype._iterateAllNodes =
- function (eventSet, binder) {
- var items = [];
- var hasResult = false;
- for (var nodeHash in this.infoPerNode) {
- var rulesPerNode = this.infoPerNode[nodeHash];
- // filter only the events we are interested in
- var filteredRules = {};
- var operFound = false;
- for (var i=0; i<eventSet.names.length; i++) {
- var name = eventSet.names[i];
- var oper = rulesPerNode[name];
- if (typeof(oper) != 'undefined') {
- filteredRules[name] = oper;
- operFound = oper;
- }
- }
- if (operFound) {
- var item = {node: operFound.node,
- opersByEventName: filteredRules};
- items.push(item);
- hasResult = true;
- }
- }
- // call the binder method
- if (hasResult) {
- this.callBindMethod(eventSet, binder, items);
- }
};
er.makeId = function(namespace, name) {
More information about the Kukit-checkins
mailing list