Thanks for the great approach.

I was wondering:

Can we use this approach to pass a HandlerFunction to the class and have this class call the HandlerFunction after it recives the response from the server (maybe returning an object parsed from the responseText).

Also what is the overhead (or performance bottleneck) of having multiple XMLhttp objects.

Thanks
Mohit

Thanks for the excellent approach. I’m new to Ajax etc., having been a pretty heads-down flash coder, but I’m starting to branch out a little. I used your class with a little modification for my portfolio site. It worked really well.

I do think the idea of separating the responsibility for loading the XMLHTTPRequest object and rendering it are most flexibly and reusably handled by handing off the rendering to a dedicated Renderer object. This is what I did at least, and seemed to work well.

For instance, in the constructor of my WRMessageLoader I have

[code]
function WRMessageLoader( pDataURL, pRenderer, pErrorHandler ) {
this._dataURL = pDataURL;
this._renderer = pRenderer;

if( pErrorHandler != undefined ) {
this._errorHandler = pErrorHandler;
}
}
[/code]

Then in my _onData method I do this (I’ve used the convenience variable p for WRMessageLoader.prototype):

[code]
p._onData = function() {

if( this._request.readyState == 4 ) {

if( this._request.status == "200" ) {
this._renderer.render( this._request );
}
else {
this._handleError(
{ loaderMessage: "Load Failed.",
status: this._request.status,
statusText: this._request.statusText } );
}

delete this._request;
}
};
[/code]

So my renderer just implements a render() method that tackes the XMLHTTPRequest object as a parameter, and it can then use the responseText or responseXML on that depending on how it wants to render.

Here’s what _handleError() does, btw:
[code]
p._handleError = function( pMessageObject ) {
pMessageObject.source = this;

if( this._errorHandler != undefined ) {

if( typeof this._errorHandler == "function" ) {
this._errorHandler( pMessageObject );
}
else {
this._errorHandler.onError( pMessageObject );
}
}
};
[/code]

I also potentially call that from load():

[code]
p.load = function() {
this._request = this._getXMLHTTPRequest();

if( !this._request ) {
this._handleError( { loaderMessage: "Could not create HTTPRequest object." } );
return false;
}

var ml = this;

this._request.onreadystatechange = function() {
ml._onData();
};

this._request.open( "GET", this._dataURL, true );
this._request.send("");

return true;
};
[/code]

Thanks again Mike — this helped quite a lot!

Well, the same thing applies regardless of where your XMLHttpRequest object lives.

The point is, that you need to pass in a reference to the dom node that you will be appending content to.

mike chambers

mesh@adobe.com

var o = MessageLoader.prototype;
o.load = function(){};

etc, etc wouldn’t go amiss!

Soon you’ll be realising you can use your AS classes in JS and you JS classes in AS and have one single ECMA class lib, oh you’ve probably changed all your AS classes to AS2, shame ;)

I have yet to see anyone but xhtml hobbyists (for lack of a better term) using it. If you are using xhtml 1.0 sent as text/html mime type it’s perfectly fine (and probably faster, and will probably save you some kbs) to use innerHTML when writing responses.