I have two abstracted processes (e.g. managed within js objects using the revealing module pattern that do not expose their internals) that fire custom events when they complete. I want to perform an action when both custom events have fired.
The new Deferred logic in jQuery 1.5 seems like it would be an ideal way to manage this, except that the when() method takes Deferred objects that return a promise() (or normal js objects, but then when() completes immediately instead of waiting, which is useless to me).
Ideally I would like to do something like:
//execute when both customevent1 and customevent2 have been fired
$.when('customevent1 customevent2').done(function(){
//do something
});
What would be the best way to marry these two techniques?
You can have the event handlers for "customevent1" and "customevent2" each signal a "Deferred" instance when they fire. You can use "$.when()" then to combine those two into one, and that's where you put the handler to fire only after both custom events have fired.
Old answer, here for completeness sake
You can make your own Deferred object that keeps track of the two conditions and fires "resolve" when both are set:
Now you can call that function:
And now your event handlers for those events just need to call "resolve" on that thing when they catch the events:
Each handler reports its own type. Only when all of the event types requested when you called "watchEvents" have happened will the handler functions you register on "df" actually get called.
It occurs to me that another thing you could do would be to write a jQuery plugin that initializes a Deferred object for elements, and stores it in a ".data()" property. You could then write some more plugins that can be used by event handlers to signal themselves, and other plugins to register handlers for multi-event sequences. That'd be pretty cool, I think, but I need to spend some time pondering it.
http://jsfiddle.net/ch47n/
I created a small plugin that creates a new jQuery.fn.when method.
Syntax is:
It uses jQuery.when() extensively internally and ensures that all events have been triggered on all elements in the collection before resolving.
Actual plugin code below: