1 /*  Prototype JavaScript framework, version 1.5.0_rc1

     2  *  (c) 2005 Sam Stephenson <sam@conio.net>

     3  *

     4  *  Prototype is freely distributable under the terms of an MIT-style license.

     5  *  For details, see the Prototype web site: http://prototype.conio.net/

     6  *

     7 /*--------------------------------------------------------------------------*/

     8 

     9 var Prototype = {

    10   Version: '1.5.0_rc1',

    11   ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',

    12 

    13   emptyFunction: function() {},

    14   K: function(x) {return x}

    15 }

    16 

    17 var Class = {

    18   create: function() {

    19     return function() {

    20       this.initialize.apply(this, arguments);

    21     }

    22   }

    23 }

    24 

    25 var Abstract = new Object();

    26 

    27 Object.extend = function(destination, source) {

    28   for (var property in source) {

    29     destination[property] = source[property];

    30   }

    31   return destination;

    32 }

    33 

    34 Object.extend(Object, {

    35   inspect: function(object) {

    36     try {

    37       if (object == undefined) return 'undefined';

    38       if (object == null) return 'null';

    39       return object.inspect ? object.inspect() : object.toString();

    40     } catch (e) {

    41       if (e instanceof RangeError) return '...';

    42       throw e;

    43     }

    44   },

    45 

    46   keys: function(object) {

    47     var keys = [];

    48     for (var property in object)

    49       keys.push(property);

    50     return keys;

    51   },

    52 

    53   values: function(object) {

    54     var values = [];

    55     for (var property in object)

    56       values.push(object[property]);

    57     return values;

    58   },

    59 

    60   clone: function(object) {

    61     return Object.extend({}, object);

    62   }

    63 });

    64 

    65 Function.prototype.bind = function() {

    66   var __method = this, args = $A(arguments), object = args.shift();

    67   return function() {

    68     return __method.apply(object, args.concat($A(arguments)));

    69   }

    70 }

    71 

    72 Function.prototype.bindAsEventListener = function(object) {

    73   var __method = this, args = $A(arguments), object = args.shift();

    74   return function(event) {

    75     return __method.apply(object, [( event || window.event)].concat(args).concat($A(arguments)));

    76   }

    77 }

    78 

    79 Object.extend(Number.prototype, {

    80   toColorPart: function() {

    81     var digits = this.toString(16);

    82     if (this < 16) return '0' + digits;

    83     return digits;

    84   },

    85 

    86   succ: function() {

    87     return this + 1;

    88   },

    89 

    90   times: function(iterator) {

    91     $R(0, this, true).each(iterator);

    92     return this;

    93   }

    94 });

    95 

    96 var Try = {

    97   these: function() {

    98     var returnValue;

    99 

   100     for (var i = 0; i < arguments.length; i++) {

   101       var lambda = arguments[i];

   102       try {

   103         returnValue = lambda();

   104         break;

   105       } catch (e) {}

   106     }

   107 

   108     return returnValue;

   109   }

   110 }

   111 

   112 /*--------------------------------------------------------------------------*/

   113 

   114 var PeriodicalExecuter = Class.create();

   115 PeriodicalExecuter.prototype = {

   116   initialize: function(callback, frequency) {

   117     this.callback = callback;

   118     this.frequency = frequency;

   119     this.currentlyExecuting = false;

   120 

   121     this.registerCallback();

   122   },

   123 

   124   registerCallback: function() {

   125     this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);

   126   },

   127 

   128   stop: function() {

   129     if (!this.timer) return;

   130     clearInterval(this.timer);

   131     this.timer = null;

   132   },

   133 

   134   onTimerEvent: function() {

   135     if (!this.currentlyExecuting) {

   136       try {

   137         this.currentlyExecuting = true;

   138         this.callback(this);

   139       } finally {

   140         this.currentlyExecuting = false;

   141       }

   142     }

   143   }

   144 }

   145 Object.extend(String.prototype, {

   146   gsub: function(pattern, replacement) {

   147     var result = '', source = this, match;

   148     replacement = arguments.callee.prepareReplacement(replacement);

   149 

   150     while (source.length > 0) {

   151       if (match = source.match(pattern)) {

   152         result += source.slice(0, match.index);

   153         result += (replacement(match) || '').toString();

   154         source  = source.slice(match.index + match[0].length);

   155       } else {

   156         result += source, source = '';

   157       }

   158     }

   159     return result;

   160   },

   161 

   162   sub: function(pattern, replacement, count) {

   163     replacement = this.gsub.prepareReplacement(replacement);

   164     count = count === undefined ? 1 : count;

   165 

   166     return this.gsub(pattern, function(match) {

   167       if (--count < 0) return match[0];

   168       return replacement(match);

   169     });

   170   },

   171 

   172   scan: function(pattern, iterator) {

   173     this.gsub(pattern, iterator);

   174     return this;

   175   },

   176 

   177   truncate: function(length, truncation) {

   178     length = length || 30;

   179     truncation = truncation === undefined ? '...' : truncation;

   180     return this.length > length ?

   181       this.slice(0, length - truncation.length) + truncation : this;

   182   },

   183 

   184   strip: function() {

   185     return this.replace(/^\s+/, '').replace(/\s+$/, '');

   186   },

   187 

   188   stripTags: function() {

   189     return this.replace(/<\/?[^>]+>/gi, '');

   190   },

   191 

   192   stripScripts: function() {

   193     return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');

   194   },

   195 

   196   extractScripts: function() {

   197     var matchAll = new RegExp(Prototype.ScriptFragment, 'img');

   198     var matchOne = new RegExp(Prototype.ScriptFragment, 'im');

   199     return (this.match(matchAll) || []).map(function(scriptTag) {

   200       return (scriptTag.match(matchOne) || ['', ''])[1];

   201     });

   202   },

   203 

   204   evalScripts: function() {

   205     return this.extractScripts().map(function(script) { return eval(script) });

   206   },

   207 

   208   escapeHTML: function() {

   209     var div = document.createElement('div');

   210     var text = document.createTextNode(this);

   211     div.appendChild(text);

   212     return div.innerHTML;

   213   },

   214 

   215   unescapeHTML: function() {

   216     var div = document.createElement('div');

   217     div.innerHTML = this.stripTags();

   218     return div.childNodes[0] ? div.childNodes[0].nodeValue : '';

   219   },

   220 

   221   toQueryParams: function() {

   222     var pairs = this.match(/^\??(.*)$/)[1].split('&');

   223     return pairs.inject({}, function(params, pairString) {

   224       var pair  = pairString.split('=');

   225       var value = pair[1] ? decodeURIComponent(pair[1]) : undefined;

   226       params[decodeURIComponent(pair[0])] = value;

   227       return params;

   228     });

   229   },

   230 

   231   toArray: function() {

   232     return this.split('');

   233   },

   234 

   235   camelize: function() {

   236     var oStringList = this.split('-');

   237     if (oStringList.length == 1) return oStringList[0];

   238 

   239     var camelizedString = this.indexOf('-') == 0

   240       ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1)

   241       : oStringList[0];

   242 

   243     for (var i = 1, len = oStringList.length; i < len; i++) {

   244       var s = oStringList[i];

   245       camelizedString += s.charAt(0).toUpperCase() + s.substring(1);

   246     }

   247 

   248     return camelizedString;

   249   },

   250 

   251   inspect: function(useDoubleQuotes) {

   252     var escapedString = this.replace(/\\/g, '\\\\');

   253     if (useDoubleQuotes)

   254       return '"' + escapedString.replace(/"/g, '\\"') + '"';

   255     else

   256       return "'" + escapedString.replace(/'/g, '\\\'') + "'";

   257   }

   258 });

   259 

   260 String.prototype.gsub.prepareReplacement = function(replacement) {

   261   if (typeof replacement == 'function') return replacement;

   262   var template = new Template(replacement);

   263   return function(match) { return template.evaluate(match) };

   264 }

   265 

   266 String.prototype.parseQuery = String.prototype.toQueryParams;

   267 

   268 var Template = Class.create();

   269 Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;

   270 Template.prototype = {

   271   initialize: function(template, pattern) {

   272     this.template = template.toString();

   273     this.pattern  = pattern || Template.Pattern;

   274   },

   275 

   276   evaluate: function(object) {

   277     return this.template.gsub(this.pattern, function(match) {

   278       var before = match[1];

   279       if (before == '\\') return match[2];

   280       return before + (object[match[3]] || '').toString();

   281     });

   282   }

   283 }

   284 

   285 var $break    = new Object();

   286 var $continue = new Object();

   287 

   288 var Enumerable = {

   289   each: function(iterator) {

   290     var index = 0;

   291     try {

   292       this._each(function(value) {

   293         try {

   294           iterator(value, index++);

   295         } catch (e) {

   296           if (e != $continue) throw e;

   297         }

   298       });

   299     } catch (e) {

   300       if (e != $break) throw e;

   301     }

   302   },

   303 

   304   all: function(iterator) {

   305     var result = true;

   306     this.each(function(value, index) {

   307       result = result && !!(iterator || Prototype.K)(value, index);

   308       if (!result) throw $break;

   309     });

   310     return result;

   311   },

   312 

   313   any: function(iterator) {

   314     var result = false;

   315     this.each(function(value, index) {

   316       if (result = !!(iterator || Prototype.K)(value, index))

   317         throw $break;

   318     });

   319     return result;

   320   },

   321 

   322   collect: function(iterator) {

   323     var results = [];

   324     this.each(function(value, index) {

   325       results.push(iterator(value, index));

   326     });

   327     return results;

   328   },

   329 

   330   detect: function (iterator) {

   331     var result;

   332     this.each(function(value, index) {

   333       if (iterator(value, index)) {

   334         result = value;

   335         throw $break;

   336       }

   337     });

   338     return result;

   339   },

   340 

   341   findAll: function(iterator) {

   342     var results = [];

   343     this.each(function(value, index) {

   344       if (iterator(value, index))

   345         results.push(value);

   346     });

   347     return results;

   348   },

   349 

   350   grep: function(pattern, iterator) {

   351     var results = [];

   352     this.each(function(value, index) {

   353       var stringValue = value.toString();

   354       if (stringValue.match(pattern))

   355         results.push((iterator || Prototype.K)(value, index));

   356     })

   357     return results;

   358   },

   359 

   360   include: function(object) {

   361     var found = false;

   362     this.each(function(value) {

   363       if (value == object) {

   364         found = true;

   365         throw $break;

   366       }

   367     });

   368     return found;

   369   },

   370 

   371   inject: function(memo, iterator) {

   372     this.each(function(value, index) {

   373       memo = iterator(memo, value, index);

   374     });

   375     return memo;

   376   },

   377 

   378   invoke: function(method) {

   379     var args = $A(arguments).slice(1);

   380     return this.collect(function(value) {

   381       return value[method].apply(value, args);

   382     });

   383   },

   384 

   385   max: function(iterator) {

   386     var result;

   387     this.each(function(value, index) {

   388       value = (iterator || Prototype.K)(value, index);

   389       if (result == undefined || value >= result)

   390         result = value;

   391     });

   392     return result;

   393   },

   394 

   395   min: function(iterator) {

   396     var result;

   397     this.each(function(value, index) {

   398       value = (iterator || Prototype.K)(value, index);

   399       if (result == undefined || value < result)

   400         result = value;

   401     });

   402     return result;

   403   },

   404 

   405   partition: function(iterator) {

   406     var trues = [], falses = [];

   407     this.each(function(value, index) {

   408       ((iterator || Prototype.K)(value, index) ?

   409         trues : falses).push(value);

   410     });

   411     return [trues, falses];

   412   },

   413 

   414   pluck: function(property) {

   415     var results = [];

   416     this.each(function(value, index) {

   417       results.push(value[property]);

   418     });

   419     return results;

   420   },

   421 

   422   reject: function(iterator) {

   423     var results = [];

   424     this.each(function(value, index) {

   425       if (!iterator(value, index))

   426         results.push(value);

   427     });

   428     return results;

   429   },

   430 

   431   sortBy: function(iterator) {

   432     return this.collect(function(value, index) {

   433       return {value: value, criteria: iterator(value, index)};

   434     }).sort(function(left, right) {

   435       var a = left.criteria, b = right.criteria;

   436       return a < b ? -1 : a > b ? 1 : 0;

   437     }).pluck('value');

   438   },

   439 

   440   toArray: function() {

   441     return this.collect(Prototype.K);

   442   },

   443 

   444   zip: function() {

   445     var iterator = Prototype.K, args = $A(arguments);

   446     if (typeof args.last() == 'function')

   447       iterator = args.pop();

   448 

   449     var collections = [this].concat(args).map($A);

   450     return this.map(function(value, index) {

   451       return iterator(collections.pluck(index));

   452     });

   453   },

   454 

   455   inspect: function() {

   456     return '#<Enumerable:' + this.toArray().inspect() + '>';

   457   }

   458 }

   459 

   460 Object.extend(Enumerable, {

   461   map:     Enumerable.collect,

   462   find:    Enumerable.detect,

   463   select:  Enumerable.findAll,

   464   member:  Enumerable.include,

   465   entries: Enumerable.toArray

   466 });

   467 var $A = Array.from = function(iterable) {

   468   if (!iterable) return [];

   469   if (iterable.toArray) {

   470     return iterable.toArray();

   471   } else {

   472     var results = [];

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

   474       results.push(iterable[i]);

   475     return results;

   476   }

   477 }

   478 

   479 Object.extend(Array.prototype, Enumerable);

   480 

   481 if (!Array.prototype._reverse)

   482   Array.prototype._reverse = Array.prototype.reverse;

   483 

   484 Object.extend(Array.prototype, {

   485   _each: function(iterator) {

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

   487       iterator(this[i]);

   488   },

   489 

   490   clear: function() {

   491     this.length = 0;

   492     return this;

   493   },

   494 

   495   first: function() {

   496     return this[0];

   497   },

   498 

   499   last: function() {

   500     return this[this.length - 1];

   501   },

   502 

   503   compact: function() {

   504     return this.select(function(value) {

   505       return value != undefined || value != null;

   506     });

   507   },

   508 

   509   flatten: function() {

   510     return this.inject([], function(array, value) {

   511       return array.concat(value && value.constructor == Array ?

   512         value.flatten() : [value]);

   513     });

   514   },

   515 

   516   without: function() {

   517     var values = $A(arguments);

   518     return this.select(function(value) {

   519       return !values.include(value);

   520     });

   521   },

   522 

   523   indexOf: function(object) {

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

   525       if (this[i] == object) return i;

   526     return -1;

   527   },

   528 

   529   reverse: function(inline) {

   530     return (inline !== false ? this : this.toArray())._reverse();

   531   },

   532 

   533   reduce: function() {

   534     return this.length > 1 ? this : this[0];

   535   },

   536 

   537   uniq: function() {

   538     return this.inject([], function(array, value) {

   539       return array.include(value) ? array : array.concat([value]);

   540     });

   541   },

   542 

   543   inspect: function() {

   544     return '[' + this.map(Object.inspect).join(', ') + ']';

   545   }

   546 });

   547 var Hash = {

   548   _each: function(iterator) {

   549     for (var key in this) {

   550       var value = this[key];

   551       if (typeof value == 'function') continue;

   552 

   553       var pair = [key, value];

   554       pair.key = key;

   555       pair.value = value;

   556       iterator(pair);

   557     }

   558   },

   559 

   560   keys: function() {

   561     return this.pluck('key');

   562   },

   563 

   564   values: function() {

   565     return this.pluck('value');

   566   },

   567 

   568   merge: function(hash) {

   569     return $H(hash).inject($H(this), function(mergedHash, pair) {

   570       mergedHash[pair.key] = pair.value;

   571       return mergedHash;

   572     });

   573   },

   574 

   575   toQueryString: function() {

   576     return this.map(function(pair) {

   577       return pair.map(encodeURIComponent).join('=');

   578     }).join('&');

   579   },

   580 

   581   inspect: function() {

   582     return '#<Hash:{' + this.map(function(pair) {

   583       return pair.map(Object.inspect).join(': ');

   584     }).join(', ') + '}>';

   585   }

   586 }

   587 

   588 function $H(object) {

   589   var hash = Object.extend({}, object || {});

   590   Object.extend(hash, Enumerable);

   591   Object.extend(hash, Hash);

   592   return hash;

   593 }

   594 ObjectRange = Class.create();

   595 Object.extend(ObjectRange.prototype, Enumerable);

   596 Object.extend(ObjectRange.prototype, {

   597   initialize: function(start, end, exclusive) {

   598     this.start = start;

   599     this.end = end;

   600     this.exclusive = exclusive;

   601   },

   602 

   603   _each: function(iterator) {

   604     var value = this.start;

   605     while (this.include(value)) {

   606       iterator(value);

   607       value = value.succ();

   608     }

   609   },

   610 

   611   include: function(value) {

   612     if (value < this.start)

   613       return false;

   614     if (this.exclusive)

   615       return value < this.end;

   616     return value <= this.end;

   617   }

   618 });

   619 

   620 var $R = function(start, end, exclusive) {

   621   return new ObjectRange(start, end, exclusive);

   622 }

   623 

   624 var Ajax = {

   625   getTransport: function() {

   626     return Try.these(

   627       function() {return new XMLHttpRequest()},

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

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

   630     ) || false;

   631   },

   632 

   633   activeRequestCount: 0

   634 }

   635 

   636 Ajax.Responders = {

   637   responders: [],

   638 

   639   _each: function(iterator) {

   640     this.responders._each(iterator);

   641   },

   642 

   643   register: function(responderToAdd) {

   644     if (!this.include(responderToAdd))

   645       this.responders.push(responderToAdd);

   646   },

   647 

   648   unregister: function(responderToRemove) {

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

   650   },

   651 

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

   653     this.each(function(responder) {

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

   655         try {

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

   657         } catch (e) {}

   658       }

   659     });

   660   }

   661 };

   662 

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

   664 

   665 Ajax.Responders.register({

   666   onCreate: function() {

   667     Ajax.activeRequestCount++;

   668   },

   669 

   670   onComplete: function() {

   671     Ajax.activeRequestCount--;

   672   }

   673 });

   674 

   675 Ajax.Base = function() {};

   676 Ajax.Base.prototype = {

   677   setOptions: function(options) {

   678     this.options = {

   679       method:       'post',

   680       asynchronous: true,

   681       contentType:  'application/x-www-form-urlencoded',

   682       parameters:   ''

   683     }

   684     Object.extend(this.options, options || {});

   685   },

   686 

   687   responseIsSuccess: function() {

   688     return this.transport.status == undefined

   689         || this.transport.status == 0

   690         || (this.transport.status >= 200 && this.transport.status < 300);

   691   },

   692 

   693   responseIsFailure: function() {

   694     return !this.responseIsSuccess();

   695   }

   696 }

   697 

   698 Ajax.Request = Class.create();

   699 Ajax.Request.Events =

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

   701 

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

   703   initialize: function(url, options) {

   704     this.transport = Ajax.getTransport();

   705     this.setOptions(options);

   706     this.request(url);

   707   },

   708 

   709   request: function(url) {

   710     var parameters = this.options.parameters || '';

   711     if (parameters.length > 0) parameters += '&_=';

   712 

   713     /* Simulate other verbs over post */

   714     if (this.options.method != 'get' && this.options.method != 'post') {

   715       parameters += (parameters.length > 0 ? '&' : '') + '_method=' + this.options.method;

   716       this.options.method = 'post';

   717     }

   718 

   719     try {

   720       this.url = url;

   721       if (this.options.method == 'get' && parameters.length > 0)

   722         this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;

   723 

   724       Ajax.Responders.dispatch('onCreate', this, this.transport);

   725 

   726       this.transport.open(this.options.method, this.url,

   727         this.options.asynchronous);

   728 

   729       if (this.options.asynchronous)

   730         setTimeout(function() { this.respondToReadyState(1) }.bind(this), 10);

   731 

   732       this.transport.onreadystatechange = this.onStateChange.bind(this);

   733       this.setRequestHeaders();

   734 

   735       var body = this.options.postBody ? this.options.postBody : parameters;

   736       this.transport.send(this.options.method == 'post' ? body : null);

   737 

   738       /* Force Firefox to handle ready state 4 for synchronous requests */

   739       if (!this.options.asynchronous && this.transport.overrideMimeType)

   740         this.onStateChange();

   741 

   742     } catch (e) {

   743       this.dispatchException(e);

   744     }

   745   },

   746 

   747   setRequestHeaders: function() {

   748     var requestHeaders =

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

   750        'X-Prototype-Version', Prototype.Version,

   751        'Accept', 'text/javascript, text/html, application/xml, text/xml, */*'];

   752 

   753     if (this.options.method == 'post') {

   754       requestHeaders.push('Content-type', this.options.contentType);

   755 

   756       /* Force "Connection: close" for Mozilla browsers to work around

   757        * a bug where XMLHttpReqeuest sends an incorrect Content-length

   758        * header. See Mozilla Bugzilla #246651.

   759        */

   760       if (this.transport.overrideMimeType)

   761         requestHeaders.push('Connection', 'close');

   762     }

   763 

   764     if (this.options.requestHeaders)

   765       requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);

   766 

   767     for (var i = 0; i < requestHeaders.length; i += 2)

   768       this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);

   769   },

   770 

   771   onStateChange: function() {

   772     var readyState = this.transport.readyState;

   773     if (readyState != 1)

   774       this.respondToReadyState(this.transport.readyState);

   775   },

   776 

   777   header: function(name) {

   778     try {

   779       return this.transport.getResponseHeader(name);

   780     } catch (e) {}

   781   },

   782 

   783   evalJSON: function() {

   784     try {

   785       return eval('(' + this.header('X-JSON') + ')');

   786     } catch (e) {}

   787   },

   788 

   789   evalResponse: function() {

   790     try {

   791       return eval(this.transport.responseText);

   792     } catch (e) {

   793       this.dispatchException(e);

   794     }

   795   },

   796 

   797   respondToReadyState: function(readyState) {

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

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

   800 

   801     if (event == 'Complete') {

   802       try {

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

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

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

   806       } catch (e) {

   807         this.dispatchException(e);

   808       }

   809 

   810       if ((this.header('Content-type') || '').match(/^text\/javascript/i))

   811         this.evalResponse();

   812     }

   813 

   814     try {

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

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

   817     } catch (e) {

   818       this.dispatchException(e);

   819     }

   820 

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

   822     if (event == 'Complete')

   823       this.transport.onreadystatechange = Prototype.emptyFunction;

   824   },

   825 

   826   dispatchException: function(exception) {

   827     (this.options.onException || Prototype.emptyFunction)(this, exception);

   828     Ajax.Responders.dispatch('onException', this, exception);

   829   }

   830 });

   831 

   832 Ajax.Updater = Class.create();

   833 

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

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

   836     this.containers = {

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

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

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

   840     }

   841 

   842     this.transport = Ajax.getTransport();

   843     this.setOptions(options);

   844 

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

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

   847       this.updateContent();

   848       onComplete(transport, object);

   849     }).bind(this);

   850 

   851     this.request(url);

   852   },

   853 

   854   updateContent: function() {

   855     var receiver = this.responseIsSuccess() ?

   856       this.containers.success : this.containers.failure;

   857     var response = this.transport.responseText;

   858 

   859     if (!this.options.evalScripts)

   860       response = response.stripScripts();

   861 

   862     if (receiver) {

   863       if (this.options.insertion) {

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

   865       } else {

   866         Element.update(receiver, response);

   867       }

   868     }

   869 

   870     if (this.responseIsSuccess()) {

   871       if (this.onComplete)

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

   873     }

   874   }

   875 });

   876 

   877 Ajax.PeriodicalUpdater = Class.create();

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

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

   880     this.setOptions(options);

   881     this.onComplete = this.options.onComplete;

   882 

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

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

   885 

   886     this.updater = {};

   887     this.container = container;

   888     this.url = url;

   889 

   890     this.start();

   891   },

   892 

   893   start: function() {

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

   895     this.onTimerEvent();

   896   },

   897 

   898   stop: function() {

   899     this.updater.options.onComplete = undefined;

   900     clearTimeout(this.timer);

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

   902   },

   903 

   904   updateComplete: function(request) {

   905     if (this.options.decay) {

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

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

   908 

   909       this.lastText = request.responseText;

   910     }

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

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

   913   },

   914 

   915   onTimerEvent: function() {

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

   917   }

   918 });

   919 function $() {

   920   var results = [], element;

   921   for (var i = 0; i < arguments.length; i++) {

   922     element = arguments[i];

   923     if (typeof element == 'string')

   924       element = document.getElementById(element);

   925     results.push(Element.extend(element));

   926   }

   927   return results.reduce();

   928 }

   929 

   930 document.getElementsByClassName = function(className, parentElement) {

   931   var children = ($(parentElement) || document.body).getElementsByTagName('*');

   932   return $A(children).inject([], function(elements, child) {

   933     if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))

   934       elements.push(Element.extend(child));

   935     return elements;

   936   });

   937 }

   938 

   939 /*--------------------------------------------------------------------------*/

   940 

   941 if (!window.Element)

   942   var Element = new Object();

   943 

   944 Element.extend = function(element) {

   945   if (!element) return;

   946   if (_nativeExtensions || element.nodeType == 3) return element;

   947 

   948   if (!element._extended && element.tagName && element != window) {

   949     var methods = Object.clone(Element.Methods), cache = Element.extend.cache;

   950 

   951     if (element.tagName == 'FORM')

   952       Object.extend(methods, Form.Methods);

   953     if (['INPUT', 'TEXTAREA', 'SELECT'].include(element.tagName))

   954       Object.extend(methods, Form.Element.Methods);

   955 

   956     for (var property in methods) {

   957       var value = methods[property];

   958       if (typeof value == 'function')

   959         element[property] = cache.findOrStore(value);

   960     }

   961   }

   962 

   963   element._extended = true;

   964   return element;

   965 }

   966 

   967 Element.extend.cache = {

   968   findOrStore: function(value) {

   969     return this[value] = this[value] || function() {

   970       return value.apply(null, [this].concat($A(arguments)));

   971     }

   972   }

   973 }

   974 

   975 Element.Methods = {

   976   visible: function(element) {

   977     return $(element).style.display != 'none';

   978   },

   979 

   980   toggle: function(element) {

   981     element = $(element);

   982     Element[Element.visible(element) ? 'hide' : 'show'](element);

   983     return element;

   984   },

   985 

   986   hide: function(element) {

   987     $(element).style.display = 'none';

   988     return element;

   989   },

   990 

   991   show: function(element) {

   992     $(element).style.display = '';

   993     return element;

   994   },

   995 

   996   remove: function(element) {

   997     element = $(element);

   998     element.parentNode.removeChild(element);

   999     return element;

  1000   },

  1001 

  1002   update: function(element, html) {

  1003     $(element).innerHTML = html.stripScripts();

  1004     setTimeout(function() {html.evalScripts()}, 10);

  1005     return element;

  1006   },

  1007 

  1008   replace: function(element, html) {

  1009     element = $(element);

  1010     if (element.outerHTML) {

  1011       element.outerHTML = html.stripScripts();

  1012     } else {

  1013       var range = element.ownerDocument.createRange();

  1014       range.selectNodeContents(element);

  1015       element.parentNode.replaceChild(

  1016         range.createContextualFragment(html.stripScripts()), element);

  1017     }

  1018     setTimeout(function() {html.evalScripts()}, 10);

  1019     return element;

  1020   },

  1021 

  1022   inspect: function(element) {

  1023     element = $(element);

  1024     var result = '<' + element.tagName.toLowerCase();

  1025     $H({'id': 'id', 'className': 'class'}).each(function(pair) {

  1026       var property = pair.first(), attribute = pair.last();

  1027       var value = (element[property] || '').toString();

  1028       if (value) result += ' ' + attribute + '=' + value.inspect(true);

  1029     });

  1030     return result + '>';

  1031   },

  1032 

  1033   recursivelyCollect: function(element, property) {

  1034     element = $(element);

  1035     var elements = [];

  1036     while (element = element[property])

  1037       if (element.nodeType == 1)

  1038         elements.push(Element.extend(element));

  1039     return elements;

  1040   },

  1041 

  1042   ancestors: function(element) {

  1043     return $(element).recursivelyCollect('parentNode');

  1044   },

  1045 

  1046   descendants: function(element) {

  1047     element = $(element);

  1048     return $A(element.getElementsByTagName('*'));

  1049   },

  1050 

  1051   previousSiblings: function(element) {

  1052     return $(element).recursivelyCollect('previousSibling');

  1053   },

  1054 

  1055   nextSiblings: function(element) {

  1056     return $(element).recursivelyCollect('nextSibling');

  1057   },

  1058 

  1059   siblings: function(element) {

  1060     element = $(element);

  1061     return element.previousSiblings().reverse().concat(element.nextSiblings());

  1062   },

  1063 

  1064   match: function(element, selector) {

  1065     element = $(element);

  1066     if (typeof selector == 'string')

  1067       selector = new Selector(selector);

  1068     return selector.match(element);

  1069   },

  1070 

  1071   up: function(element, expression, index) {

  1072     return Selector.findElement($(element).ancestors(), expression, index);

  1073   },

  1074 

  1075   down: function(element, expression, index) {

  1076     return Selector.findElement($(element).descendants(), expression, index);

  1077   },

  1078 

  1079   previous: function(element, expression, index) {

  1080     return Selector.findElement($(element).previousSiblings(), expression, index);

  1081   },

  1082 

  1083   next: function(element, expression, index) {

  1084     return Selector.findElement($(element).nextSiblings(), expression, index);

  1085   },

  1086 

  1087   getElementsBySelector: function() {

  1088     var args = $A(arguments), element = $(args.shift());

  1089     return Selector.findChildElements(element, args);

  1090   },

  1091 

  1092   getElementsByClassName: function(element, className) {

  1093     element = $(element);

  1094     return document.getElementsByClassName(className, element);

  1095   },

  1096 

  1097   getHeight: function(element) {

  1098     element = $(element);

  1099     return element.offsetHeight;

  1100   },

  1101 

  1102   classNames: function(element) {

  1103     return new Element.ClassNames(element);

  1104   },

  1105 

  1106   hasClassName: function(element, className) {

  1107     if (!(element = $(element))) return;

  1108     return Element.classNames(element).include(className);

  1109   },

  1110 

  1111   addClassName: function(element, className) {

  1112     if (!(element = $(element))) return;

  1113     Element.classNames(element).add(className);

  1114     return element;

  1115   },

  1116 

  1117   removeClassName: function(element, className) {

  1118     if (!(element = $(element))) return;

  1119     Element.classNames(element).remove(className);

  1120     return element;

  1121   },

  1122 

  1123   observe: function() {

  1124     Event.observe.apply(Event, arguments);

  1125     return $A(arguments).first();

  1126   },

  1127 

  1128   stopObserving: function() {

  1129     Event.stopObserving.apply(Event, arguments);

  1130     return $A(arguments).first();

  1131   },

  1132 

  1133   // removes whitespace-only text node children

  1134   cleanWhitespace: function(element) {

  1135     element = $(element);

  1136     var node = element.firstChild;