Merged r1559:r1587 from source:/sandbox/crschmidt/noprototype. OpenLayers is now Prototype-free(tm).

git-svn-id: http://svn.openlayers.org/trunk/openlayers@1588 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf

lib/OpenLayers/Ajax.js

@@ -60,7 +60,7 @@ OpenLayers.loadURL = function(uri, params, caller,
                            : OpenLayers.nullHandler;
 
     // from prototype.js
-    new Ajax.Request(uri, 
+    new OpenLayers.Ajax.Request(uri, 
                      {   method: 'get', 
                          parameters: params,
                          onComplete: success, 
@@ -83,7 +83,7 @@ OpenLayers.parseXMLString = function(text) {
         text = text.substring(index);
     }
 
-    var ajaxResponse = Try.these(
+    var ajaxResponse = OpenLayers.Util.Try(
         function() {
             var xmldom = new ActiveXObject('Microsoft.XMLDOM');
             xmldom.loadXML(text);
@@ -106,3 +106,197 @@ OpenLayers.parseXMLString = function(text) {
 
     return ajaxResponse;
 };
+
+OpenLayers.Ajax = {
+  emptyFunction: function () {},
+
+  getTransport: function() {
+    return OpenLayers.Util.Try(
+      function() {return new ActiveXObject('Msxml2.XMLHTTP')},
+      function() {return new ActiveXObject('Microsoft.XMLHTTP')},
+      function() {return new XMLHttpRequest()}
+    ) || false;
+  },
+
+  activeRequestCount: 0
+};
+
+OpenLayers.Ajax.Responders = {
+  responders: [],
+
+  register: function(responderToAdd) {
+    for (var i = 0; i < this.responders.length; i++)
+        if (responderToAdd == this.responders[i])
+            return;
+    this.responders.push(responderToAdd);
+  },
+
+  dispatch: function(callback, request, transport, json) {
+    for (var i = 0; i < this.responders.length; i++) {
+      responder = this.responders[i];
+      if (responder[callback] && typeof responder[callback] == 'function') {
+        try {
+          responder[callback].apply(responder, [request, transport, json]);
+        } catch (e) {}
+      }
+    }
+  }
+};
+
+OpenLayers.Ajax.Responders.register({
+  onCreate: function() {
+    OpenLayers.Ajax.activeRequestCount++;
+  },
+
+  onComplete: function() {
+    OpenLayers.Ajax.activeRequestCount--;
+  }
+});
+
+OpenLayers.Ajax.Base = function() {};
+OpenLayers.Ajax.Base.prototype = {
+  setOptions: function(options) {
+    this.options = {
+      method:       'post',
+      asynchronous: true,
+      parameters:   ''
+    }
+    OpenLayers.Util.extend(this.options, options || {});
+  },
+
+  responseIsSuccess: function() {
+    return this.transport.status == undefined
+        || this.transport.status == 0
+        || (this.transport.status >= 200 && this.transport.status < 300);
+  },
+
+  responseIsFailure: function() {
+    return !this.responseIsSuccess();
+  }
+}
+
+OpenLayers.Ajax.Request = OpenLayers.Class.create();
+OpenLayers.Ajax.Request.Events =
+  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
+
+OpenLayers.Ajax.Request.prototype = OpenLayers.Util.extend(new OpenLayers.Ajax.Base(), {
+  initialize: function(url, options) {
+    this.transport = OpenLayers.Ajax.getTransport();
+    this.setOptions(options);
+    this.request(url);
+  },
+
+  request: function(url) {
+    var parameters = this.options.parameters || '';
+    if (parameters.length > 0) parameters += '&_=';
+
+    try {
+      this.url = url;
+      if (this.options.method == 'get' && parameters.length > 0)
+        this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;
+
+      OpenLayers.Ajax.Responders.dispatch('onCreate', this, this.transport);
+
+      this.transport.open(this.options.method, this.url,
+        this.options.asynchronous);
+
+      if (this.options.asynchronous) {
+        this.transport.onreadystatechange = this.onStateChange.bind(this);
+        setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10);
+      }
+
+      this.setRequestHeaders();
+
+      var body = this.options.postBody ? this.options.postBody : parameters;
+      this.transport.send(this.options.method == 'post' ? body : null);
+
+    } catch (e) {
+      this.dispatchException(e);
+    }
+  },
+
+  setRequestHeaders: function() {
+    var requestHeaders =
+      ['X-Requested-With', 'XMLHttpRequest',
+       'X-Prototype-Version', 'OpenLayers'];
+
+    if (this.options.method == 'post') {
+      requestHeaders.push('Content-type',
+        'application/x-www-form-urlencoded');
+
+      /* Force "Connection: close" for Mozilla browsers to work around
+       * a bug where XMLHttpReqeuest sends an incorrect Content-length
+       * header. See Mozilla Bugzilla #246651.
+       */
+      if (this.transport.overrideMimeType)
+        requestHeaders.push('Connection', 'close');
+    }
+
+    if (this.options.requestHeaders)
+      requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);
+
+    for (var i = 0; i < requestHeaders.length; i += 2)
+      this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);
+  },
+
+  onStateChange: function() {
+    var readyState = this.transport.readyState;
+    if (readyState != 1)
+      this.respondToReadyState(this.transport.readyState);
+  },
+
+  header: function(name) {
+    try {
+      return this.transport.getResponseHeader(name);
+    } catch (e) {}
+  },
+
+  evalJSON: function() {
+    try {
+      return eval(this.header('X-JSON'));
+    } catch (e) {}
+  },
+
+  evalResponse: function() {
+    try {
+      return eval(this.transport.responseText);
+    } catch (e) {
+      this.dispatchException(e);
+    }
+  },
+
+  respondToReadyState: function(readyState) {
+    var event = OpenLayers.Ajax.Request.Events[readyState];
+    var transport = this.transport, json = this.evalJSON();
+
+    if (event == 'Complete') {
+      try {
+        (this.options['on' + this.transport.status]
+         || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
+         || OpenLayers.Ajax.emptyFunction)(transport, json);
+      } catch (e) {
+        this.dispatchException(e);
+      }
+
+      if ((this.header('Content-type') || '').match(/^text\/javascript/i))
+        this.evalResponse();
+    }
+
+    try {
+      (this.options['on' + event] || OpenLayers.Ajax.emptyFunction)(transport, json);
+      OpenLayers.Ajax.Responders.dispatch('on' + event, this, transport, json);
+    } catch (e) {
+      this.dispatchException(e);
+    }
+
+    /* Avoid memory leak in MSIE: clean up the oncomplete event handler */
+    if (event == 'Complete')
+      this.transport.onreadystatechange = OpenLayers.Ajax.emptyFunction;
+  },
+
+  dispatchException: function(exception) {
+    (this.options.onException || OpenLayers.Ajax.emptyFunction)(this, exception);
+    OpenLayers.Ajax.Responders.dispatch('onException', this, exception);
+  }
+});
+