If Function.apply is not available in a browser, this will be run and it do the smae thing:

if(!Function.prototype.apply)
{
Function.prototype.apply = function(o,a)
{
var r, e;
if(!o) var o = window;
if(!a) var a = new Array();
var b = new Array();
for(var i=0;i

Hope to speak to you soon, my friend.

The reason I posted this today was becasue I saw that they were doing something similar in Google maps.

Object.prototype.eventHandler = function (sMeth) {
var self = this;
return function (e) {
if (!e) e = window.event;
if (!e.target) e = e.srcElement;
// I would add preventDefault and stopPropagation as well
return self[sMeth](e);
};
};

Keep posting these tips btw. As protoscript says, you have a clear writing and coding style.

Nice thing about it is that 1. it can be applied to anything and 2. it preserves the original scope in a way that is very clear.

Thought you might be interested.

For commercial APIs I recommend using what you are suggesting or doing what we are doing in Bindows.

Bindows:

this.obj.addEventLsitener(”foo”, this.handleFoo, this)

f(m)?

this.obj.OnFoo.Add(new Events.EventHandler(this.handleFoo));

The documentation was a bit confusing here. I could not read out how to do it in the right way to get this.handleFoo working as expected. You say that it takes 2 arguments so then I hope it would finally end up something like this:

this.obj.OnFoo.Add(this.handleFoo, this)

The good thing with this over the W3C/Bindows model is that the events can be discovered more easily. The bad thing is that custom events require an interface change.

function myHandler(src, ea) {
// do something
}

this.obj.OnFoo.Add(new Events.EventHandler(myHandler))

…like that. I suppose I should really go through and make that clearer…

a.b.OnFoo.Add(new Events.EventHandler(a.handleFoo))

How would I get to a in a.handleFoo (when called from the event handler)? I get the impression that src would point to a.b? At least that is how .NET does it.

The difference is that the event handler is executed in the scope of “a” in your example, *not* in the scope of “b”; in this particular case, the src arg of your event handler *should* be a reference to “b”. So yes, it works very much like the way .NET does (which was the point, a lot of the aim of f(m) is to bring some of the cleanliness of the .NET framework to JS).

The big difference with what I’ve done is that it’s a unified model; it works the same whether or not you are firing custom events on your own objects, or you’ve attached them to DOM objects. Which is pretty nice. I was kind of impressed with myself when I was able to pull something like this:

document.getElementById(”myFoo”).onclick = (new Events.Listener()).Invoke ;
document.getElementById(”myFoo”).onclick.Add(new Events.MouseEventHandler(myHandlerFunc)) ;