1 files changed, 268 insertions, 0 deletions

diff --git a/framework/Web/Javascripts/prototype/ajax.js b/framework/Web/Javascripts/prototype/ajax.js
new file mode 100644
index 00000000..1fe0dab9
--- /dev/null
+++ b/framework/Web/Javascripts/prototype/ajax.js
@@ -0,0 +1,268 @@
+var Ajax = {

+  getTransport: function() {

+    return Try.these(

+      function() {return new ActiveXObject('Msxml2.XMLHTTP')},

+      function() {return new ActiveXObject('Microsoft.XMLHTTP')},

+      function() {return new XMLHttpRequest()}

+    ) || false;

+  },

+  

+  activeRequestCount: 0

+}

+

+Ajax.Responders = {

+  responders: [],

+  

+  _each: function(iterator) {

+    this.responders._each(iterator);

+  },

+

+  register: function(responderToAdd) {

+    if (!this.include(responderToAdd))

+      this.responders.push(responderToAdd);

+  },

+  

+  unregister: function(responderToRemove) {

+    this.responders = this.responders.without(responderToRemove);

+  },

+  

+  dispatch: function(callback, request, transport, json) {

+    this.each(function(responder) {

+      if (responder[callback] && typeof responder[callback] == 'function') {

+        try {

+          responder[callback].apply(responder, [request, transport, json]);

+        } catch (e) {

+        }

+      }

+    });

+  }

+};

+

+Object.extend(Ajax.Responders, Enumerable);

+

+Ajax.Responders.register({

+  onCreate: function() {

+    Ajax.activeRequestCount++;

+  },

+  

+  onComplete: function() {

+    Ajax.activeRequestCount--;

+  }

+});

+

+Ajax.Base = function() {};

+Ajax.Base.prototype = {

+  setOptions: function(options) {

+    this.options = {

+      method:       'post',

+      asynchronous: true,

+      parameters:   ''

+    }

+    Object.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();

+  }

+}

+

+Ajax.Request = Class.create();

+Ajax.Request.Events = 

+  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

+

+Ajax.Request.prototype = Object.extend(new Ajax.Base(), {

+  initialize: function(url, options) {

+    this.transport = 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;

+      

+      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.options.onException || Prototype.emptyFunction)(this, e);

+      Ajax.Responders.dispatch('onException', this, e);

+    }

+  },

+

+  setRequestHeaders: function() {

+    var requestHeaders = 

+      ['X-Requested-With', 'XMLHttpRequest',

+       'X-Prototype-Version', Prototype.Version];

+

+    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);

+  },

+  

+  evalJSON: function() {

+    try {

+      var json = this.transport.getResponseHeader('X-JSON'), object;

+      object = eval(json);

+      return object;

+    } catch (e) {

+    }

+  },

+

+  respondToReadyState: function(readyState) {

+    var event = Ajax.Request.Events[readyState];

+    var transport = this.transport, json = this.evalJSON();

+

+    if (event == 'Complete')

+      (this.options['on' + this.transport.status]

+       || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]

+       || Prototype.emptyFunction)(transport, json);

+

+    (this.options['on' + event] || Prototype.emptyFunction)(transport, json);

+    Ajax.Responders.dispatch('on' + event, this, transport, json);

+

+    /* Avoid memory leak in MSIE: clean up the oncomplete event handler */

+    if (event == 'Complete')

+      this.transport.onreadystatechange = Prototype.emptyFunction;

+  }

+});

+

+Ajax.Updater = Class.create();

+Ajax.Updater.ScriptFragment = '(?:<script.*?>)((\n|.)*?)(?:<\/script>)';

+

+Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {

+  initialize: function(container, url, options) {

+    this.containers = {

+      success: container.success ? $(container.success) : $(container),

+      failure: container.failure ? $(container.failure) :

+        (container.success ? null : $(container))

+    }

+

+    this.transport = Ajax.getTransport();

+    this.setOptions(options);

+

+    var onComplete = this.options.onComplete || Prototype.emptyFunction;

+    this.options.onComplete = (function(transport, object) {

+      this.updateContent();

+      onComplete(transport, object);

+    }).bind(this);

+

+    this.request(url);

+  },

+

+  updateContent: function() {

+    var receiver = this.responseIsSuccess() ?

+      this.containers.success : this.containers.failure;

+

+    var match    = new RegExp(Ajax.Updater.ScriptFragment, 'img');

+    var response = this.transport.responseText.replace(match, '');

+    var scripts  = this.transport.responseText.match(match);

+

+    if (receiver) {

+      if (this.options.insertion) {

+        new this.options.insertion(receiver, response);

+      } else {

+        receiver.innerHTML = response;

+      }

+    }

+

+    if (this.responseIsSuccess()) {

+      if (this.onComplete)

+        setTimeout(this.onComplete.bind(this), 10);

+    }

+

+    if (this.options.evalScripts && scripts) {

+      match = new RegExp(Ajax.Updater.ScriptFragment, 'im');

+      setTimeout((function() {

+        for (var i = 0; i < scripts.length; i++)

+          eval(scripts[i].match(match)[1]);

+      }).bind(this), 10);

+    }

+  }

+});

+

+Ajax.PeriodicalUpdater = Class.create();

+Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {

+  initialize: function(container, url, options) {

+    this.setOptions(options);

+    this.onComplete = this.options.onComplete;

+

+    this.frequency = (this.options.frequency || 2);

+    this.decay = (this.options.decay || 1);

+    

+    this.updater = {};

+    this.container = container;

+    this.url = url;

+

+    this.start();

+  },

+

+  start: function() {

+    this.options.onComplete = this.updateComplete.bind(this);

+    this.onTimerEvent();

+  },

+

+  stop: function() {

+    this.updater.onComplete = undefined;

+    clearTimeout(this.timer);

+    (this.onComplete || Prototype.emptyFunction).apply(this, arguments);

+  },

+

+  updateComplete: function(request) {

+    if (this.options.decay) {

+      this.decay = (request.responseText == this.lastText ? 

+        this.decay * this.options.decay : 1);

+

+      this.lastText = request.responseText;

+    }

+    this.timer = setTimeout(this.onTimerEvent.bind(this), 

+      this.decay * this.frequency * 1000);

+  },

+

+  onTimerEvent: function() {

+    this.updater = new Ajax.Updater(this.container, this.url, this.options);

+  }

+});