public/javascripts/prototype.js

   1 /*  Prototype JavaScript framework, version 1.5.0_rc0
   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_rc0',
  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.inspect = function(object) {
  35   try {
  36     if (object == undefined) return 'undefined';
  37     if (object == null) return 'null';
  38     return object.inspect ? object.inspect() : object.toString();
  39   } catch (e) {
  40     if (e instanceof RangeError) return '...';
  41     throw e;
  42   }
  43 }
  44
  45 Function.prototype.bind = function() {
  46   var __method = this, args = $A(arguments), object = args.shift();
  47   return function() {
  48     return __method.apply(object, args.concat($A(arguments)));
  49   }
  50 }
  51
  52 Function.prototype.bindAsEventListener = function(object) {
  53   var __method = this;
  54   return function(event) {
  55     return __method.call(object, event || window.event);
  56   }
  57 }
  58
  59 Object.extend(Number.prototype, {
  60   toColorPart: function() {
  61     var digits = this.toString(16);
  62     if (this < 16) return '0' + digits;
  63     return digits;
  64   },
  65
  66   succ: function() {
  67     return this + 1;
  68   },
  69
  70   times: function(iterator) {
  71     $R(0, this, true).each(iterator);
  72     return this;
  73   }
  74 });
  75
  76 var Try = {
  77   these: function() {
  78     var returnValue;
  79
  80     for (var i = 0; i < arguments.length; i++) {
  81       var lambda = arguments[i];
  82       try {
  83         returnValue = lambda();
  84         break;
  85       } catch (e) {}
  86     }
  87
  88     return returnValue;
  89   }
  90 }
  91
  92 /*--------------------------------------------------------------------------*/
  93
  94 var PeriodicalExecuter = Class.create();
  95 PeriodicalExecuter.prototype = {
  96   initialize: function(callback, frequency) {
  97     this.callback = callback;
  98     this.frequency = frequency;
  99     this.currentlyExecuting = false;
 100
 101     this.registerCallback();
 102   },
 103
 104   registerCallback: function() {
 105     setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
 106   },
 107
 108   onTimerEvent: function() {
 109     if (!this.currentlyExecuting) {
 110       try {
 111         this.currentlyExecuting = true;
 112         this.callback();
 113       } finally {
 114         this.currentlyExecuting = false;
 115       }
 116     }
 117   }
 118 }
 119 Object.extend(String.prototype, {
 120   gsub: function(pattern, replacement) {
 121     var result = '', source = this, match;
 122     replacement = arguments.callee.prepareReplacement(replacement);
 123
 124     while (source.length > 0) {
 125       if (match = source.match(pattern)) {
 126         result += source.slice(0, match.index);
 127         result += (replacement(match) || '').toString();
 128         source  = source.slice(match.index + match[0].length);
 129       } else {
 130         result += source, source = '';
 131       }
 132     }
 133     return result;
 134   },
 135
 136   sub: function(pattern, replacement, count) {
 137     replacement = this.gsub.prepareReplacement(replacement);
 138     count = count === undefined ? 1 : count;
 139
 140     return this.gsub(pattern, function(match) {
 141       if (--count < 0) return match[0];
 142       return replacement(match);
 143     });
 144   },
 145
 146   scan: function(pattern, iterator) {
 147     this.gsub(pattern, iterator);
 148     return this;
 149   },
 150
 151   truncate: function(length, truncation) {
 152     length = length || 30;
 153     truncation = truncation === undefined ? '...' : truncation;
 154     return this.length > length ?
 155       this.slice(0, length - truncation.length) + truncation : this;
 156   },
 157
 158   strip: function() {
 159     return this.replace(/^\s+/, '').replace(/\s+$/, '');
 160   },
 161
 162   stripTags: function() {
 163     return this.replace(/<\/?[^>]+>/gi, '');
 164   },
 165
 166   stripScripts: function() {
 167     return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
 168   },
 169
 170   extractScripts: function() {
 171     var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
 172     var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
 173     return (this.match(matchAll) || []).map(function(scriptTag) {
 174       return (scriptTag.match(matchOne) || ['', ''])[1];
 175     });
 176   },
 177
 178   evalScripts: function() {
 179     return this.extractScripts().map(function(script) { return eval(script) });
 180   },
 181
 182   escapeHTML: function() {
 183     var div = document.createElement('div');
 184     var text = document.createTextNode(this);
 185     div.appendChild(text);
 186     return div.innerHTML;
 187   },
 188
 189   unescapeHTML: function() {
 190     var div = document.createElement('div');
 191     div.innerHTML = this.stripTags();
 192     return div.childNodes[0] ? div.childNodes[0].nodeValue : '';
 193   },
 194
 195   toQueryParams: function() {
 196     var pairs = this.match(/^\??(.*)$/)[1].split('&');
 197     return pairs.inject({}, function(params, pairString) {
 198       var pair = pairString.split('=');
 199       params[pair[0]] = pair[1];
 200       return params;
 201     });
 202   },
 203
 204   toArray: function() {
 205     return this.split('');
 206   },
 207
 208   camelize: function() {
 209     var oStringList = this.split('-');
 210     if (oStringList.length == 1) return oStringList[0];
 211
 212     var camelizedString = this.indexOf('-') == 0
 213       ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1)
 214       : oStringList[0];
 215
 216     for (var i = 1, len = oStringList.length; i < len; i++) {
 217       var s = oStringList[i];
 218       camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
 219     }
 220
 221     return camelizedString;
 222   },
 223
 224   inspect: function() {
 225     return "'" + this.replace(/\\/g, '\\\\').replace(/'/g, '\\\'') + "'";
 226   }
 227 });
 228
 229 String.prototype.gsub.prepareReplacement = function(replacement) {
 230   if (typeof replacement == 'function') return replacement;
 231   var template = new Template(replacement);
 232   return function(match) { return template.evaluate(match) };
 233 }
 234
 235 String.prototype.parseQuery = String.prototype.toQueryParams;
 236
 237 var Template = Class.create();
 238 Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
 239 Template.prototype = {
 240   initialize: function(template, pattern) {
 241     this.template = template.toString();
 242     this.pattern  = pattern || Template.Pattern;
 243   },
 244
 245   evaluate: function(object) {
 246     return this.template.gsub(this.pattern, function(match) {
 247       var before = match[1];
 248       if (before == '\\') return match[2];
 249       return before + (object[match[3]] || '').toString();
 250     });
 251   }
 252 }
 253
 254 var $break    = new Object();
 255 var $continue = new Object();
 256
 257 var Enumerable = {
 258   each: function(iterator) {
 259     var index = 0;
 260     try {
 261       this._each(function(value) {
 262         try {
 263           iterator(value, index++);
 264         } catch (e) {
 265           if (e != $continue) throw e;
 266         }
 267       });
 268     } catch (e) {
 269       if (e != $break) throw e;
 270     }
 271   },
 272
 273   all: function(iterator) {
 274     var result = true;
 275     this.each(function(value, index) {
 276       result = result && !!(iterator || Prototype.K)(value, index);
 277       if (!result) throw $break;
 278     });
 279     return result;
 280   },
 281
 282   any: function(iterator) {
 283     var result = true;
 284     this.each(function(value, index) {
 285       if (result = !!(iterator || Prototype.K)(value, index))
 286         throw $break;
 287     });
 288     return result;
 289   },
 290
 291   collect: function(iterator) {
 292     var results = [];
 293     this.each(function(value, index) {
 294       results.push(iterator(value, index));
 295     });
 296     return results;
 297   },
 298
 299   detect: function (iterator) {
 300     var result;
 301     this.each(function(value, index) {
 302       if (iterator(value, index)) {
 303         result = value;
 304         throw $break;
 305       }
 306     });
 307     return result;
 308   },
 309
 310   findAll: function(iterator) {
 311     var results = [];
 312     this.each(function(value, index) {
 313       if (iterator(value, index))
 314         results.push(value);
 315     });
 316     return results;
 317   },
 318
 319   grep: function(pattern, iterator) {
 320     var results = [];
 321     this.each(function(value, index) {
 322       var stringValue = value.toString();
 323       if (stringValue.match(pattern))
 324         results.push((iterator || Prototype.K)(value, index));
 325     })
 326     return results;
 327   },
 328
 329   include: function(object) {
 330     var found = false;
 331     this.each(function(value) {
 332       if (value == object) {
 333         found = true;
 334         throw $break;
 335       }
 336     });
 337     return found;
 338   },
 339
 340   inject: function(memo, iterator) {
 341     this.each(function(value, index) {
 342       memo = iterator(memo, value, index);
 343     });
 344     return memo;
 345   },
 346
 347   invoke: function(method) {
 348     var args = $A(arguments).slice(1);
 349     return this.collect(function(value) {
 350       return value[method].apply(value, args);
 351     });
 352   },
 353
 354   max: function(iterator) {
 355     var result;
 356     this.each(function(value, index) {
 357       value = (iterator || Prototype.K)(value, index);
 358       if (result == undefined || value >= result)
 359         result = value;
 360     });
 361     return result;
 362   },
 363
 364   min: function(iterator) {
 365     var result;
 366     this.each(function(value, index) {
 367       value = (iterator || Prototype.K)(value, index);
 368       if (result == undefined || value < result)
 369         result = value;
 370     });
 371     return result;
 372   },
 373
 374   partition: function(iterator) {
 375     var trues = [], falses = [];
 376     this.each(function(value, index) {
 377       ((iterator || Prototype.K)(value, index) ?
 378         trues : falses).push(value);
 379     });
 380     return [trues, falses];
 381   },
 382
 383   pluck: function(property) {
 384     var results = [];
 385     this.each(function(value, index) {
 386       results.push(value[property]);
 387     });
 388     return results;
 389   },
 390
 391   reject: function(iterator) {
 392     var results = [];
 393     this.each(function(value, index) {
 394       if (!iterator(value, index))
 395         results.push(value);
 396     });
 397     return results;
 398   },
 399
 400   sortBy: function(iterator) {
 401     return this.collect(function(value, index) {
 402       return {value: value, criteria: iterator(value, index)};
 403     }).sort(function(left, right) {
 404       var a = left.criteria, b = right.criteria;
 405       return a < b ? -1 : a > b ? 1 : 0;
 406     }).pluck('value');
 407   },
 408
 409   toArray: function() {
 410     return this.collect(Prototype.K);
 411   },
 412
 413   zip: function() {
 414     var iterator = Prototype.K, args = $A(arguments);
 415     if (typeof args.last() == 'function')
 416       iterator = args.pop();
 417
 418     var collections = [this].concat(args).map($A);
 419     return this.map(function(value, index) {
 420       return iterator(collections.pluck(index));
 421     });
 422   },
 423
 424   inspect: function() {
 425     return '#<Enumerable:' + this.toArray().inspect() + '>';
 426   }
 427 }
 428
 429 Object.extend(Enumerable, {
 430   map:     Enumerable.collect,
 431   find:    Enumerable.detect,
 432   select:  Enumerable.findAll,
 433   member:  Enumerable.include,
 434   entries: Enumerable.toArray
 435 });
 436 var $A = Array.from = function(iterable) {
 437   if (!iterable) return [];
 438   if (iterable.toArray) {
 439     return iterable.toArray();
 440   } else {
 441     var results = [];
 442     for (var i = 0; i < iterable.length; i++)
 443       results.push(iterable[i]);
 444     return results;
 445   }
 446 }
 447
 448 Object.extend(Array.prototype, Enumerable);
 449
 450 if (!Array.prototype._reverse)
 451   Array.prototype._reverse = Array.prototype.reverse;
 452
 453 Object.extend(Array.prototype, {
 454   _each: function(iterator) {
 455     for (var i = 0; i < this.length; i++)
 456       iterator(this[i]);
 457   },
 458
 459   clear: function() {
 460     this.length = 0;
 461     return this;
 462   },
 463
 464   first: function() {
 465     return this[0];
 466   },
 467
 468   last: function() {
 469     return this[this.length - 1];
 470   },
 471
 472   compact: function() {
 473     return this.select(function(value) {
 474       return value != undefined || value != null;
 475     });
 476   },
 477
 478   flatten: function() {
 479     return this.inject([], function(array, value) {
 480       return array.concat(value && value.constructor == Array ?
 481         value.flatten() : [value]);
 482     });
 483   },
 484
 485   without: function() {
 486     var values = $A(arguments);
 487     return this.select(function(value) {
 488       return !values.include(value);
 489     });
 490   },
 491
 492   indexOf: function(object) {
 493     for (var i = 0; i < this.length; i++)
 494       if (this[i] == object) return i;
 495     return -1;
 496   },
 497
 498   reverse: function(inline) {
 499     return (inline !== false ? this : this.toArray())._reverse();
 500   },
 501
 502   inspect: function() {
 503     return '[' + this.map(Object.inspect).join(', ') + ']';
 504   }
 505 });
 506 var Hash = {
 507   _each: function(iterator) {
 508     for (var key in this) {
 509       var value = this[key];
 510       if (typeof value == 'function') continue;
 511
 512       var pair = [key, value];
 513       pair.key = key;
 514       pair.value = value;
 515       iterator(pair);
 516     }
 517   },
 518
 519   keys: function() {
 520     return this.pluck('key');
 521   },
 522
 523   values: function() {
 524     return this.pluck('value');
 525   },
 526
 527   merge: function(hash) {
 528     return $H(hash).inject($H(this), function(mergedHash, pair) {
 529       mergedHash[pair.key] = pair.value;
 530       return mergedHash;
 531     });
 532   },
 533
 534   toQueryString: function() {
 535     return this.map(function(pair) {
 536       return pair.map(encodeURIComponent).join('=');
 537     }).join('&');
 538   },
 539
 540   inspect: function() {
 541     return '#<Hash:{' + this.map(function(pair) {
 542       return pair.map(Object.inspect).join(': ');
 543     }).join(', ') + '}>';
 544   }
 545 }
 546
 547 function $H(object) {
 548   var hash = Object.extend({}, object || {});
 549   Object.extend(hash, Enumerable);
 550   Object.extend(hash, Hash);
 551   return hash;
 552 }
 553 ObjectRange = Class.create();
 554 Object.extend(ObjectRange.prototype, Enumerable);
 555 Object.extend(ObjectRange.prototype, {
 556   initialize: function(start, end, exclusive) {
 557     this.start = start;
 558     this.end = end;
 559     this.exclusive = exclusive;
 560   },
 561
 562   _each: function(iterator) {
 563     var value = this.start;
 564     do {
 565       iterator(value);
 566       value = value.succ();
 567     } while (this.include(value));
 568   },
 569
 570   include: function(value) {
 571     if (value < this.start)
 572       return false;
 573     if (this.exclusive)
 574       return value < this.end;
 575     return value <= this.end;
 576   }
 577 });
 578
 579 var $R = function(start, end, exclusive) {
 580   return new ObjectRange(start, end, exclusive);
 581 }
 582
 583 var Ajax = {
 584   getTransport: function() {
 585     return Try.these(
 586       function() {return new XMLHttpRequest()},
 587       function() {return new ActiveXObject('Msxml2.XMLHTTP')},
 588       function() {return new ActiveXObject('Microsoft.XMLHTTP')}
 589     ) || false;
 590   },
 591
 592   activeRequestCount: 0
 593 }
 594
 595 Ajax.Responders = {
 596   responders: [],
 597
 598   _each: function(iterator) {
 599     this.responders._each(iterator);
 600   },
 601
 602   register: function(responderToAdd) {
 603     if (!this.include(responderToAdd))
 604       this.responders.push(responderToAdd);
 605   },
 606
 607   unregister: function(responderToRemove) {
 608     this.responders = this.responders.without(responderToRemove);
 609   },
 610
 611   dispatch: function(callback, request, transport, json) {
 612     this.each(function(responder) {
 613       if (responder[callback] && typeof responder[callback] == 'function') {
 614         try {
 615           responder[callback].apply(responder, [request, transport, json]);
 616         } catch (e) {}
 617       }
 618     });
 619   }
 620 };
 621
 622 Object.extend(Ajax.Responders, Enumerable);
 623
 624 Ajax.Responders.register({
 625   onCreate: function() {
 626     Ajax.activeRequestCount++;
 627   },
 628
 629   onComplete: function() {
 630     Ajax.activeRequestCount--;
 631   }
 632 });
 633
 634 Ajax.Base = function() {};
 635 Ajax.Base.prototype = {
 636   setOptions: function(options) {
 637     this.options = {
 638       method:       'post',
 639       asynchronous: true,
 640       contentType:  'application/x-www-form-urlencoded',
 641       parameters:   ''
 642     }
 643     Object.extend(this.options, options || {});
 644   },
 645
 646   responseIsSuccess: function() {
 647     return this.transport.status == undefined
 648         || this.transport.status == 0
 649         || (this.transport.status >= 200 && this.transport.status < 300);
 650   },
 651
 652   responseIsFailure: function() {
 653     return !this.responseIsSuccess();
 654   }
 655 }
 656
 657 Ajax.Request = Class.create();
 658 Ajax.Request.Events =
 659   ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
 660
 661 Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
 662   initialize: function(url, options) {
 663     this.transport = Ajax.getTransport();
 664     this.setOptions(options);
 665     this.request(url);
 666   },
 667
 668   request: function(url) {
 669     var parameters = this.options.parameters || '';
 670     if (parameters.length > 0) parameters += '&_=';
 671
 672     try {
 673       this.url = url;
 674       if (this.options.method == 'get' && parameters.length > 0)
 675         this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;
 676
 677       Ajax.Responders.dispatch('onCreate', this, this.transport);
 678
 679       this.transport.open(this.options.method, this.url,
 680         this.options.asynchronous);
 681
 682       if (this.options.asynchronous) {
 683         this.transport.onreadystatechange = this.onStateChange.bind(this);
 684         setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10);
 685       }
 686
 687       this.setRequestHeaders();
 688
 689       var body = this.options.postBody ? this.options.postBody : parameters;
 690       this.transport.send(this.options.method == 'post' ? body : null);
 691
 692     } catch (e) {
 693       this.dispatchException(e);
 694     }
 695   },
 696
 697   setRequestHeaders: function() {
 698     var requestHeaders =
 699       ['X-Requested-With', 'XMLHttpRequest',
 700        'X-Prototype-Version', Prototype.Version,
 701        'Accept', 'text/javascript, text/html, application/xml, text/xml, */*'];
 702
 703     if (this.options.method == 'post') {
 704       requestHeaders.push('Content-type', this.options.contentType);
 705
 706       /* Force "Connection: close" for Mozilla browsers to work around
 707        * a bug where XMLHttpReqeuest sends an incorrect Content-length
 708        * header. See Mozilla Bugzilla #246651.
 709        */
 710       if (this.transport.overrideMimeType)
 711         requestHeaders.push('Connection', 'close');
 712     }
 713
 714     if (this.options.requestHeaders)
 715       requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);
 716
 717     for (var i = 0; i < requestHeaders.length; i += 2)
 718       this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);
 719   },
 720
 721   onStateChange: function() {
 722     var readyState = this.transport.readyState;
 723     if (readyState != 1)
 724       this.respondToReadyState(this.transport.readyState);
 725   },
 726
 727   header: function(name) {
 728     try {
 729       return this.transport.getResponseHeader(name);
 730     } catch (e) {}
 731   },
 732
 733   evalJSON: function() {
 734     try {
 735       return eval('(' + this.header('X-JSON') + ')');
 736     } catch (e) {}
 737   },
 738
 739   evalResponse: function() {
 740     try {
 741       return eval(this.transport.responseText);
 742     } catch (e) {
 743       this.dispatchException(e);
 744     }
 745   },
 746
 747   respondToReadyState: function(readyState) {
 748     var event = Ajax.Request.Events[readyState];
 749     var transport = this.transport, json = this.evalJSON();
 750
 751     if (event == 'Complete') {
 752       try {
 753         (this.options['on' + this.transport.status]
 754          || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
 755          || Prototype.emptyFunction)(transport, json);
 756       } catch (e) {
 757         this.dispatchException(e);
 758       }
 759
 760       if ((this.header('Content-type') || '').match(/^text\/javascript/i))
 761         this.evalResponse();
 762     }
 763
 764     try {
 765       (this.options['on' + event] || Prototype.emptyFunction)(transport, json);
 766       Ajax.Responders.dispatch('on' + event, this, transport, json);
 767     } catch (e) {
 768       this.dispatchException(e);
 769     }
 770
 771     /* Avoid memory leak in MSIE: clean up the oncomplete event handler */
 772     if (event == 'Complete')
 773       this.transport.onreadystatechange = Prototype.emptyFunction;
 774   },
 775
 776   dispatchException: function(exception) {
 777     (this.options.onException || Prototype.emptyFunction)(this, exception);
 778     Ajax.Responders.dispatch('onException', this, exception);
 779   }
 780 });
 781
 782 Ajax.Updater = Class.create();
 783
 784 Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
 785   initialize: function(container, url, options) {
 786     this.containers = {
 787       success: container.success ? $(container.success) : $(container),
 788       failure: container.failure ? $(container.failure) :
 789         (container.success ? null : $(container))
 790     }
 791
 792     this.transport = Ajax.getTransport();
 793     this.setOptions(options);
 794
 795     var onComplete = this.options.onComplete || Prototype.emptyFunction;
 796     this.options.onComplete = (function(transport, object) {
 797       this.updateContent();
 798       onComplete(transport, object);
 799     }).bind(this);
 800
 801     this.request(url);
 802   },
 803
 804   updateContent: function() {
 805     var receiver = this.responseIsSuccess() ?
 806       this.containers.success : this.containers.failure;
 807     var response = this.transport.responseText;
 808
 809     if (!this.options.evalScripts)
 810       response = response.stripScripts();
 811
 812     if (receiver) {
 813       if (this.options.insertion) {
 814         new this.options.insertion(receiver, response);
 815       } else {
 816         Element.update(receiver, response);
 817       }
 818     }
 819
 820     if (this.responseIsSuccess()) {
 821       if (this.onComplete)
 822         setTimeout(this.onComplete.bind(this), 10);
 823     }
 824   }
 825 });
 826
 827 Ajax.PeriodicalUpdater = Class.create();
 828 Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
 829   initialize: function(container, url, options) {
 830     this.setOptions(options);
 831     this.onComplete = this.options.onComplete;
 832
 833     this.frequency = (this.options.frequency || 2);
 834     this.decay = (this.options.decay || 1);
 835
 836     this.updater = {};
 837     this.container = container;
 838     this.url = url;
 839
 840     this.start();
 841   },
 842
 843   start: function() {
 844     this.options.onComplete = this.updateComplete.bind(this);
 845     this.onTimerEvent();
 846   },
 847
 848   stop: function() {
 849     this.updater.onComplete = undefined;
 850     clearTimeout(this.timer);
 851     (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
 852   },
 853
 854   updateComplete: function(request) {
 855     if (this.options.decay) {
 856       this.decay = (request.responseText == this.lastText ?
 857         this.decay * this.options.decay : 1);
 858
 859       this.lastText = request.responseText;
 860     }
 861     this.timer = setTimeout(this.onTimerEvent.bind(this),
 862       this.decay * this.frequency * 1000);
 863   },
 864
 865   onTimerEvent: function() {
 866     this.updater = new Ajax.Updater(this.container, this.url, this.options);
 867   }
 868 });
 869 function $() {
 870   var results = [], element;
 871   for (var i = 0; i < arguments.length; i++) {
 872     element = arguments[i];
 873     if (typeof element == 'string')
 874       element = document.getElementById(element);
 875     results.push(Element.extend(element));
 876   }
 877   return results.length < 2 ? results[0] : results;
 878 }
 879
 880 document.getElementsByClassName = function(className, parentElement) {
 881   var children = ($(parentElement) || document.body).getElementsByTagName('*');
 882   return $A(children).inject([], function(elements, child) {
 883     if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
 884       elements.push(Element.extend(child));
 885     return elements;
 886   });
 887 }
 888
 889 /*--------------------------------------------------------------------------*/
 890
 891 if (!window.Element)
 892   var Element = new Object();
 893
 894 Element.extend = function(element) {
 895   if (!element) return;
 896   if (_nativeExtensions) return element;
 897
 898   if (!element._extended && element.tagName && element != window) {
 899     var methods = Element.Methods, cache = Element.extend.cache;
 900     for (property in methods) {
 901       var value = methods[property];
 902       if (typeof value == 'function')
 903         element[property] = cache.findOrStore(value);
 904     }
 905   }
 906
 907   element._extended = true;
 908   return element;
 909 }
 910
 911 Element.extend.cache = {
 912   findOrStore: function(value) {
 913     return this[value] = this[value] || function() {
 914       return value.apply(null, [this].concat($A(arguments)));
 915     }
 916   }
 917 }
 918
 919 Element.Methods = {
 920   visible: function(element) {
 921     return $(element).style.display != 'none';
 922   },
 923
 924   toggle: function() {
 925     for (var i = 0; i < arguments.length; i++) {
 926       var element = $(arguments[i]);
 927       Element[Element.visible(element) ? 'hide' : 'show'](element);
 928     }
 929   },
 930
 931   hide: function() {
 932     for (var i = 0; i < arguments.length; i++) {
 933       var element = $(arguments[i]);
 934       element.style.display = 'none';
 935     }
 936   },
 937
 938   show: function() {
 939     for (var i = 0; i < arguments.length; i++) {
 940       var element = $(arguments[i]);
 941       element.style.display = '';
 942     }
 943   },
 944
 945   remove: function(element) {
 946     element = $(element);
 947     element.parentNode.removeChild(element);
 948   },
 949
 950   update: function(element, html) {
 951     $(element).innerHTML = html.stripScripts();
 952     setTimeout(function() {html.evalScripts()}, 10);
 953   },
 954
 955   replace: function(element, html) {
 956     element = $(element);
 957     if (element.outerHTML) {
 958       element.outerHTML = html.stripScripts();
 959     } else {
 960       var range = element.ownerDocument.createRange();
 961       range.selectNodeContents(element);
 962       element.parentNode.replaceChild(
 963         range.createContextualFragment(html.stripScripts()), element);
 964     }
 965     setTimeout(function() {html.evalScripts()}, 10);
 966   },
 967
 968   getHeight: function(element) {
 969     element = $(element);
 970     return element.offsetHeight;
 971   },
 972
 973   classNames: function(element) {
 974     return new Element.ClassNames(element);
 975   },
 976
 977   hasClassName: function(element, className) {
 978     if (!(element = $(element))) return;
 979     return Element.classNames(element).include(className);
 980   },
 981
 982   addClassName: function(element, className) {
 983     if (!(element = $(element))) return;
 984     return Element.classNames(element).add(className);
 985   },
 986
 987   removeClassName: function(element, className) {
 988     if (!(element = $(element))) return;
 989     return Element.classNames(element).remove(className);
 990   },
 991
 992   // removes whitespace-only text node children
 993   cleanWhitespace: function(element) {
 994     element = $(element);
 995     for (var i = 0; i < element.childNodes.length; i++) {
 996       var node = element.childNodes[i];
 997       if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
 998         Element.remove(node);
 999     }
1000   },
1001
1002   empty: function(element) {
1003     return $(element).innerHTML.match(/^\s*$/);
1004   },
1005
1006   childOf: function(element, ancestor) {
1007     element = $(element), ancestor = $(ancestor);
1008     while (element = element.parentNode)
1009       if (element == ancestor) return true;
1010     return false;
1011   },
1012
1013   scrollTo: function(element) {
1014     element = $(element);
1015     var x = element.x ? element.x : element.offsetLeft,
1016         y = element.y ? element.y : element.offsetTop;
1017     window.scrollTo(x, y);
1018   },
1019
1020   getStyle: function(element, style) {
1021     element = $(element);
1022     var value = element.style[style.camelize()];
1023     if (!value) {
1024       if (document.defaultView && document.defaultView.getComputedStyle) {
1025         var css = document.defaultView.getComputedStyle(element, null);
1026         value = css ? css.getPropertyValue(style) : null;
1027       } else if (element.currentStyle) {
1028         value = element.currentStyle[style.camelize()];
1029       }
1030     }
1031
1032     if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
1033       if (Element.getStyle(element, 'position') == 'static') value = 'auto';
1034
1035     return value == 'auto' ? null : value;
1036   },
1037
1038   setStyle: function(element, style) {
1039     element = $(element);
1040     for (var name in style)
1041       element.style[name.camelize()] = style[name];
1042   },
1043
1044   getDimensions: function(element) {
1045     element = $(element);
1046     if (Element.getStyle(element, 'display') != 'none')
1047       return {width: element.offsetWidth, height: element.offsetHeight};
1048
1049     // All *Width and *Height properties give 0 on elements with display none,
1050     // so enable the element temporarily
1051     var els = element.style;
1052     var originalVisibility = els.visibility;
1053     var originalPosition = els.position;
1054     els.visibility = 'hidden';
1055     els.position = 'absolute';
1056     els.display = '';
1057     var originalWidth = element.clientWidth;
1058     var originalHeight = element.clientHeight;
1059     els.display = 'none';
1060     els.position = originalPosition;
1061     els.visibility = originalVisibility;
1062     return {width: originalWidth, height: originalHeight};
1063   },
1064
1065   makePositioned: function(element) {
1066     element = $(element);
1067     var pos = Element.getStyle(element, 'position');
1068     if (pos == 'static' || !pos) {
1069       element._madePositioned = true;
1070       element.style.position = 'relative';
1071       // Opera returns the offset relative to the positioning context, when an
1072       // element is position relative but top and left have not been defined
1073       if (window.opera) {
1074         element.style.top = 0;
1075         element.style.left = 0;
1076       }
1077     }
1078   },
1079
1080   undoPositioned: function(element) {
1081     element = $(element);
1082     if (element._madePositioned) {
1083       element._madePositioned = undefined;
1084       element.style.position =
1085         element.style.top =
1086         element.style.left =
1087         element.style.bottom =
1088         element.style.right = '';
1089     }
1090   },
1091
1092   makeClipping: function(element) {
1093     element = $(element);
1094     if (element._overflow) return;
1095     element._overflow = element.style.overflow;
1096     if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
1097       element.style.overflow = 'hidden';
1098   },
1099
1100   undoClipping: function(element) {
1101     element = $(element);
1102     if (element._overflow) return;
1103     element.style.overflow = element._overflow;
1104     element._overflow = undefined;
1105   }
1106 }
1107
1108 Object.extend(Element, Element.Methods);
1109
1110 var _nativeExtensions = false;
1111
1112 if(!HTMLElement && /Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
1113   var HTMLElement = {}
1114   HTMLElement.prototype = document.createElement('div').__proto__;
1115 }
1116
1117 Element.addMethods = function(methods) {
1118   Object.extend(Element.Methods, methods || {});
1119
1120   if(typeof HTMLElement != 'undefined') {
1121     var methods = Element.Methods, cache = Element.extend.cache;
1122     for (property in methods) {
1123       var value = methods[property];
1124       if (typeof value == 'function')
1125         HTMLElement.prototype[property] = cache.findOrStore(value);
1126     }
1127     _nativeExtensions = true;
1128   }
1129 }
1130
1131 Element.addMethods();
1132
1133 var Toggle = new Object();
1134 Toggle.display = Element.toggle;
1135
1136 /*--------------------------------------------------------------------------*/
1137
1138 Abstract.Insertion = function(adjacency) {
1139   this.adjacency = adjacency;
1140 }
1141
1142 Abstract.Insertion.prototype = {
1143   initialize: function(element, content) {
1144     this.element = $(element);
1145     this.content = content.stripScripts();
1146
1147     if (this.adjacency && this.element.insertAdjacentHTML) {
1148       try {
1149         this.element.insertAdjacentHTML(this.adjacency, this.content);
1150       } catch (e) {
1151         var tagName = this.element.tagName.toLowerCase();
1152         if (tagName == 'tbody' || tagName == 'tr') {
1153           this.insertContent(this.contentFromAnonymousTable());
1154         } else {
1155           throw e;
1156         }
1157       }
1158     } else {
1159       this.range = this.element.ownerDocument.createRange();
1160       if (this.initializeRange) this.initializeRange();
1161       this.insertContent([this.range.createContextualFragment(this.content)]);
1162     }
1163
1164     setTimeout(function() {content.evalScripts()}, 10);
1165   },
1166
1167   contentFromAnonymousTable: function() {
1168     var div = document.createElement('div');
1169     div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
1170     return $A(div.childNodes[0].childNodes[0].childNodes);
1171   }
1172 }
1173
1174 var Insertion = new Object();
1175
1176 Insertion.Before = Class.create();
1177 Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
1178   initializeRange: function() {
1179     this.range.setStartBefore(this.element);
1180   },
1181
1182   insertContent: function(fragments) {
1183     fragments.each((function(fragment) {
1184       this.element.parentNode.insertBefore(fragment, this.element);
1185     }).bind(this));
1186   }
1187 });
1188
1189 Insertion.Top = Class.create();
1190 Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
1191   initializeRange: function() {
1192     this.range.selectNodeContents(this.element);
1193     this.range.collapse(true);
1194   },
1195
1196   insertContent: function(fragments) {
1197     fragments.reverse(false).each((function(fragment) {
1198       this.element.insertBefore(fragment, this.element.firstChild);
1199     }).bind(this));
1200   }
1201 });
1202
1203 Insertion.Bottom = Class.create();
1204 Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
1205   initializeRange: function() {
1206     this.range.selectNodeContents(this.element);
1207     this.range.collapse(this.element);
1208   },
1209
1210   insertContent: function(fragments) {
1211     fragments.each((function(fragment) {
1212       this.element.appendChild(fragment);
1213     }).bind(this));
1214   }
1215 });
1216
1217 Insertion.After = Class.create();
1218 Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
1219   initializeRange: function() {
1220     this.range.setStartAfter(this.element);
1221   },
1222
1223   insertContent: function(fragments) {
1224     fragments.each((function(fragment) {
1225       this.element.parentNode.insertBefore(fragment,
1226         this.element.nextSibling);
1227     }).bind(this));
1228   }
1229 });
1230
1231 /*--------------------------------------------------------------------------*/
1232
1233 Element.ClassNames = Class.create();
1234 Element.ClassNames.prototype = {
1235   initialize: function(element) {
1236     this.element = $(element);
1237   },
1238
1239   _each: function(iterator) {
1240     this.element.className.split(/\s+/).select(function(name) {
1241       return name.length > 0;
1242     })._each(iterator);
1243   },
1244
1245   set: function(className) {
1246     this.element.className = className;
1247   },
1248
1249   add: function(classNameToAdd) {
1250     if (this.include(classNameToAdd)) return;
1251     this.set(this.toArray().concat(classNameToAdd).join(' '));
1252   },
1253
1254   remove: function(classNameToRemove) {
1255     if (!this.include(classNameToRemove)) return;
1256     this.set(this.select(function(className) {
1257       return className != classNameToRemove;
1258     }).join(' '));
1259   },
1260
1261   toString: function() {
1262     return this.toArray().join(' ');
1263   }
1264 }
1265
1266 Object.extend(Element.ClassNames.prototype, Enumerable);
1267 var Selector = Class.create();
1268 Selector.prototype = {
1269   initialize: function(expression) {
1270     this.params = {classNames: []};
1271     this.expression = expression.toString().strip();
1272     this.parseExpression();
1273     this.compileMatcher();
1274   },
1275
1276   parseExpression: function() {
1277     function abort(message) { throw 'Parse error in selector: ' + message; }
1278
1279     if (this.expression == '')  abort('empty expression');
1280
1281     var params = this.params, expr = this.expression, match, modifier, clause, rest;
1282     while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)) {
1283       params.attributes = params.attributes || [];
1284       params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
1285       expr = match[1];
1286     }
1287
1288     if (expr == '*') return this.params.wildcard = true;
1289
1290     while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+)(.*)/i)) {
1291       modifier = match[1], clause = match[2], rest = match[3];
1292       switch (modifier) {
1293         case '#':       params.id = clause; break;
1294         case '.':       params.classNames.push(clause); break;
1295         case '':
1296         case undefined: params.tagName = clause.toUpperCase(); break;
1297         default:        abort(expr.inspect());
1298       }
1299       expr = rest;
1300     }
1301
1302     if (expr.length > 0) abort(expr.inspect());
1303   },
1304
1305   buildMatchExpression: function() {
1306     var params = this.params, conditions = [], clause;
1307
1308     if (params.wildcard)
1309       conditions.push('true');
1310     if (clause = params.id)
1311       conditions.push('element.id == ' + clause.inspect());
1312     if (clause = params.tagName)
1313       conditions.push('element.tagName.toUpperCase() == ' + clause.inspect());
1314     if ((clause = params.classNames).length > 0)
1315       for (var i = 0; i < clause.length; i++)
1316         conditions.push('Element.hasClassName(element, ' + clause[i].inspect() + ')');
1317     if (clause = params.attributes) {
1318       clause.each(function(attribute) {
1319         var value = 'element.getAttribute(' + attribute.name.inspect() + ')';
1320         var splitValueBy = function(delimiter) {
1321           return value + ' && ' + value + '.split(' + delimiter.inspect() + ')';
1322         }
1323
1324         switch (attribute.operator) {
1325           case '=':       conditions.push(value + ' == ' + attribute.value.inspect()); break;
1326           case '~=':      conditions.push(splitValueBy(' ') + '.include(' + attribute.value.inspect() + ')'); break;
1327           case '|=':      conditions.push(
1328                             splitValueBy('-') + '.first().toUpperCase() == ' + attribute.value.toUpperCase().inspect()
1329                           ); break;
1330           case '!=':      conditions.push(value + ' != ' + attribute.value.inspect()); break;
1331           case '':
1332           case undefined: conditions.push(value + ' != null'); break;
1333           default:        throw 'Unknown operator ' + attribute.operator + ' in selector';
1334         }
1335       });
1336     }
1337
1338     return conditions.join(' && ');
1339   },
1340
1341   compileMatcher: function() {
1342     this.match = new Function('element', 'if (!element.tagName) return false; \
1343       return ' + this.buildMatchExpression());
1344   },
1345
1346   findElements: function(scope) {
1347     var element;
1348
1349     if (element = $(this.params.id))
1350       if (this.match(element))
1351         if (!scope || Element.childOf(element, scope))
1352           return [element];
1353
1354     scope = (scope || document).getElementsByTagName(this.params.tagName || '*');
1355
1356     var results = [];
1357     for (var i = 0; i < scope.length; i++)
1358       if (this.match(element = scope[i]))
1359         results.push(Element.extend(element));
1360
1361     return results;
1362   },
1363
1364   toString: function() {
1365     return this.expression;
1366   }
1367 }
1368
1369 function $$() {
1370   return $A(arguments).map(function(expression) {
1371     return expression.strip().split(/\s+/).inject([null], function(results, expr) {
1372       var selector = new Selector(expr);
1373       return results.map(selector.findElements.bind(selector)).flatten();
1374     });
1375   }).flatten();
1376 }
1377 var Field = {
1378   clear: function() {
1379     for (var i = 0; i < arguments.length; i++)
1380       $(arguments[i]).value = '';
1381   },
1382
1383   focus: function(element) {
1384     $(element).focus();
1385   },
1386
1387   present: function() {
1388     for (var i = 0; i < arguments.length; i++)
1389       if ($(arguments[i]).value == '') return false;
1390     return true;
1391   },
1392
1393   select: function(element) {
1394     $(element).select();
1395   },
1396
1397   activate: function(element) {
1398     element = $(element);
1399     element.focus();
1400     if (element.select)
1401       element.select();
1402   }
1403 }
1404
1405 /*--------------------------------------------------------------------------*/
1406
1407 var Form = {
1408   serialize: function(form) {
1409     var elements = Form.getElements($(form));
1410     var queryComponents = new Array();
1411
1412     for (var i = 0; i < elements.length; i++) {
1413       var queryComponent = Form.Element.serialize(elements[i]);
1414       if (queryComponent)
1415         queryComponents.push(queryComponent);
1416     }
1417
1418     return queryComponents.join('&');
1419   },
1420
1421   getElements: function(form) {
1422     form = $(form);
1423     var elements = new Array();
1424
1425     for (var tagName in Form.Element.Serializers) {
1426       var tagElements = form.getElementsByTagName(tagName);
1427       for (var j = 0; j < tagElements.length; j++)
1428         elements.push(tagElements[j]);
1429     }
1430     return elements;
1431   },
1432
1433   getInputs: function(form, typeName, name) {
1434     form = $(form);
1435     var inputs = form.getElementsByTagName('input');
1436
1437     if (!typeName && !name)
1438       return inputs;
1439
1440     var matchingInputs = new Array();
1441     for (var i = 0; i < inputs.length; i++) {
1442       var input = inputs[i];
1443       if ((typeName && input.type != typeName) ||
1444           (name && input.name != name))
1445         continue;
1446       matchingInputs.push(input);
1447     }
1448
1449     return matchingInputs;
1450   },
1451
1452   disable: function(form) {
1453     var elements = Form.getElements(form);
1454     for (var i = 0; i < elements.length; i++) {
1455       var element = elements[i];
1456       element.blur();
1457       element.disabled = 'true';
1458     }
1459   },
1460
1461   enable: function(form) {
1462     var elements = Form.getElements(form);
1463     for (var i = 0; i < elements.length; i++) {
1464       var element = elements[i];
1465       element.disabled = '';
1466     }
1467   },
1468
1469   findFirstElement: function(form) {
1470     return Form.getElements(form).find(function(element) {
1471       return element.type != 'hidden' && !element.disabled &&
1472         ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
1473     });
1474   },
1475
1476   focusFirstElement: function(form) {
1477     Field.activate(Form.findFirstElement(form));
1478   },
1479
1480   reset: function(form) {
1481     $(form).reset();
1482   }
1483 }
1484
1485 Form.Element = {
1486   serialize: function(element) {
1487     element = $(element);
1488     var method = element.tagName.toLowerCase();
1489     var parameter = Form.Element.Serializers[method](element);
1490
1491     if (parameter) {
1492       var key = encodeURIComponent(parameter[0]);
1493       if (key.length == 0) return;
1494
1495       if (parameter[1].constructor != Array)
1496         parameter[1] = [parameter[1]];
1497
1498       return parameter[1].map(function(value) {
1499         return key + '=' + encodeURIComponent(value);
1500       }).join('&');
1501     }
1502   },
1503
1504   getValue: function(element) {
1505     element = $(element);
1506     var method = element.tagName.toLowerCase();
1507     var parameter = Form.Element.Serializers[method](element);
1508
1509     if (parameter)
1510       return parameter[1];
1511   }
1512 }
1513
1514 Form.Element.Serializers = {
1515   input: function(element) {
1516     switch (element.type.toLowerCase()) {
1517       case 'submit':
1518       case 'hidden':
1519       case 'password':
1520       case 'text':
1521         return Form.Element.Serializers.textarea(element);
1522       case 'checkbox':
1523       case 'radio':
1524         return Form.Element.Serializers.inputSelector(element);
1525     }
1526     return false;
1527   },
1528
1529   inputSelector: function(element) {
1530     if (element.checked)
1531       return [element.name, element.value];
1532   },
1533
1534   textarea: function(element) {
1535     return [element.name, element.value];
1536   },
1537
1538   select: function(element) {
1539     return Form.Element.Serializers[element.type == 'select-one' ?
1540       'selectOne' : 'selectMany'](element);
1541   },
1542
1543   selectOne: function(element) {
1544     var value = '', opt, index = element.selectedIndex;
1545     if (index >= 0) {
1546       opt = element.options[index];
1547       value = opt.value || opt.text;
1548     }
1549     return [element.name, value];
1550   },
1551
1552   selectMany: function(element) {
1553     var value = [];
1554     for (var i = 0; i < element.length; i++) {
1555       var opt = element.options[i];
1556       if (opt.selected)
1557         value.push(opt.value || opt.text);
1558     }
1559     return [element.name, value];
1560   }
1561 }
1562
1563 /*--------------------------------------------------------------------------*/
1564
1565 var $F = Form.Element.getValue;
1566
1567 /*--------------------------------------------------------------------------*/
1568
1569 Abstract.TimedObserver = function() {}
1570 Abstract.TimedObserver.prototype = {
1571   initialize: function(element, frequency, callback) {
1572     this.frequency = frequency;
1573     this.element   = $(element);
1574     this.callback  = callback;
1575
1576     this.lastValue = this.getValue();
1577     this.registerCallback();
1578   },
1579
1580   registerCallback: function() {
1581     setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
1582   },
1583
1584   onTimerEvent: function() {
1585     var value = this.getValue();
1586     if (this.lastValue != value) {
1587       this.callback(this.element, value);
1588       this.lastValue = value;
1589     }
1590   }
1591 }
1592
1593 Form.Element.Observer = Class.create();
1594 Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
1595   getValue: function() {
1596     return Form.Element.getValue(this.element);
1597   }
1598 });
1599
1600 Form.Observer = Class.create();
1601 Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
1602   getValue: function() {
1603     return Form.serialize(this.element);
1604   }
1605 });
1606
1607 /*--------------------------------------------------------------------------*/
1608
1609 Abstract.EventObserver = function() {}
1610 Abstract.EventObserver.prototype = {
1611   initialize: function(element, callback) {
1612     this.element  = $(element);
1613     this.callback = callback;
1614
1615     this.lastValue = this.getValue();
1616     if (this.element.tagName.toLowerCase() == 'form')
1617       this.registerFormCallbacks();
1618     else
1619       this.registerCallback(this.element);
1620   },
1621
1622   onElementEvent: function() {
1623     var value = this.getValue();
1624     if (this.lastValue != value) {
1625       this.callback(this.element, value);
1626       this.lastValue = value;
1627     }
1628   },
1629
1630   registerFormCallbacks: function() {
1631     var elements = Form.getElements(this.element);
1632     for (var i = 0; i < elements.length; i++)
1633       this.registerCallback(elements[i]);
1634   },
1635
1636   registerCallback: function(element) {
1637     if (element.type) {
1638       switch (element.type.toLowerCase()) {
1639         case 'checkbox':
1640         case 'radio':
1641           Event.observe(element, 'click', this.onElementEvent.bind(this));
1642           break;
1643         case 'password':
1644         case 'text':
1645         case 'textarea':
1646         case 'select-one':
1647         case 'select-multiple':
1648           Event.observe(element, 'change', this.onElementEvent.bind(this));
1649           break;
1650       }
1651     }
1652   }
1653 }
1654
1655 Form.Element.EventObserver = Class.create();
1656 Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
1657   getValue: function() {
1658     return Form.Element.getValue(this.element);
1659   }
1660 });
1661
1662 Form.EventObserver = Class.create();
1663 Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
1664   getValue: function() {
1665     return Form.serialize(this.element);
1666   }
1667 });
1668 if (!window.Event) {
1669   var Event = new Object();
1670 }
1671
1672 Object.extend(Event, {
1673   KEY_BACKSPACE: 8,
1674   KEY_TAB:       9,
1675   KEY_RETURN:   13,
1676   KEY_ESC:      27,
1677   KEY_LEFT:     37,
1678   KEY_UP:       38,
1679   KEY_RIGHT:    39,
1680   KEY_DOWN:     40,
1681   KEY_DELETE:   46,
1682
1683   element: function(event) {
1684     return event.target || event.srcElement;
1685   },
1686
1687   isLeftClick: function(event) {
1688     return (((event.which) && (event.which == 1)) ||
1689             ((event.button) && (event.button == 1)));
1690   },
1691
1692   pointerX: function(event) {
1693     return event.pageX || (event.clientX +
1694       (document.documentElement.scrollLeft || document.body.scrollLeft));
1695   },
1696
1697   pointerY: function(event) {
1698     return event.pageY || (event.clientY +
1699       (document.documentElement.scrollTop || document.body.scrollTop));
1700   },
1701
1702   stop: function(event) {
1703     if (event.preventDefault) {
1704       event.preventDefault();
1705       event.stopPropagation();
1706     } else {
1707       event.returnValue = false;
1708       event.cancelBubble = true;
1709     }
1710   },
1711
1712   // find the first node with the given tagName, starting from the
1713   // node the event was triggered on; traverses the DOM upwards
1714   findElement: function(event, tagName) {
1715     var element = Event.element(event);
1716     while (element.parentNode && (!element.tagName ||
1717         (element.tagName.toUpperCase() != tagName.toUpperCase())))
1718       element = element.parentNode;
1719     return element;
1720   },
1721
1722   observers: false,
1723
1724   _observeAndCache: function(element, name, observer, useCapture) {
1725     if (!this.observers) this.observers = [];
1726     if (element.addEventListener) {
1727       this.observers.push([element, name, observer, useCapture]);
1728       element.addEventListener(name, observer, useCapture);
1729     } else if (element.attachEvent) {
1730       this.observers.push([element, name, observer, useCapture]);
1731       element.attachEvent('on' + name, observer);
1732     }
1733   },
1734
1735   unloadCache: function() {
1736     if (!Event.observers) return;
1737     for (var i = 0; i < Event.observers.length; i++) {
1738       Event.stopObserving.apply(this, Event.observers[i]);
1739       Event.observers[i][0] = null;
1740     }
1741     Event.observers = false;
1742   },
1743
1744   observe: function(element, name, observer, useCapture) {
1745     var element = $(element);
1746     useCapture = useCapture || false;
1747
1748     if (name == 'keypress' &&
1749         (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
1750         || element.attachEvent))
1751       name = 'keydown';
1752
1753     this._observeAndCache(element, name, observer, useCapture);
1754   },
1755
1756   stopObserving: function(element, name, observer, useCapture) {
1757     var element = $(element);
1758     useCapture = useCapture || false;
1759
1760     if (name == 'keypress' &&
1761         (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
1762         || element.detachEvent))
1763       name = 'keydown';
1764
1765     if (element.removeEventListener) {
1766       element.removeEventListener(name, observer, useCapture);
1767     } else if (element.detachEvent) {
1768       element.detachEvent('on' + name, observer);
1769     }
1770   }
1771 });
1772
1773 /* prevent memory leaks in IE */
1774 if (navigator.appVersion.match(/\bMSIE\b/))
1775   Event.observe(window, 'unload', Event.unloadCache, false);
1776 var Position = {
1777   // set to true if needed, warning: firefox performance problems
1778   // NOT neeeded for page scrolling, only if draggable contained in
1779   // scrollable elements
1780   includeScrollOffsets: false,
1781
1782   // must be called before calling withinIncludingScrolloffset, every time the
1783   // page is scrolled
1784   prepare: function() {
1785     this.deltaX =  window.pageXOffset
1786                 || document.documentElement.scrollLeft
1787                 || document.body.scrollLeft
1788                 || 0;
1789     this.deltaY =  window.pageYOffset
1790                 || document.documentElement.scrollTop
1791                 || document.body.scrollTop
1792                 || 0;
1793   },
1794
1795   realOffset: function(element) {
1796     var valueT = 0, valueL = 0;
1797     do {
1798       valueT += element.scrollTop  || 0;
1799       valueL += element.scrollLeft || 0;
1800       element = element.parentNode;
1801     } while (element);
1802     return [valueL, valueT];
1803   },
1804
1805   cumulativeOffset: function(element) {
1806     var valueT = 0, valueL = 0;
1807     do {
1808       valueT += element.offsetTop  || 0;
1809       valueL += element.offsetLeft || 0;
1810       element = element.offsetParent;
1811     } while (element);
1812     return [valueL, valueT];
1813   },
1814
1815   positionedOffset: function(element) {
1816     var valueT = 0, valueL = 0;
1817     do {
1818       valueT += element.offsetTop  || 0;
1819       valueL += element.offsetLeft || 0;
1820       element = element.offsetParent;
1821       if (element) {
1822         p = Element.getStyle(element, 'position');
1823         if (p == 'relative' || p == 'absolute') break;
1824       }
1825     } while (element);
1826     return [valueL, valueT];
1827   },
1828
1829   offsetParent: function(element) {
1830     if (element.offsetParent) return element.offsetParent;
1831     if (element == document.body) return element;
1832
1833     while ((element = element.parentNode) && element != document.body)
1834       if (Element.getStyle(element, 'position') != 'static')
1835         return element;
1836
1837     return document.body;
1838   },
1839
1840   // caches x/y coordinate pair to use with overlap
1841   within: function(element, x, y) {
1842     if (this.includeScrollOffsets)
1843       return this.withinIncludingScrolloffsets(element, x, y);
1844     this.xcomp = x;
1845     this.ycomp = y;
1846     this.offset = this.cumulativeOffset(element);
1847
1848     return (y >= this.offset[1] &&
1849             y <  this.offset[1] + element.offsetHeight &&
1850             x >= this.offset[0] &&
1851             x <  this.offset[0] + element.offsetWidth);
1852   },
1853
1854   withinIncludingScrolloffsets: function(element, x, y) {
1855     var offsetcache = this.realOffset(element);
1856
1857     this.xcomp = x + offsetcache[0] - this.deltaX;
1858     this.ycomp = y + offsetcache[1] - this.deltaY;
1859     this.offset = this.cumulativeOffset(element);
1860
1861     return (this.ycomp >= this.offset[1] &&
1862             this.ycomp <  this.offset[1] + element.offsetHeight &&
1863             this.xcomp >= this.offset[0] &&
1864             this.xcomp <  this.offset[0] + element.offsetWidth);
1865   },
1866
1867   // within must be called directly before
1868   overlap: function(mode, element) {
1869     if (!mode) return 0;
1870     if (mode == 'vertical')
1871       return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
1872         element.offsetHeight;
1873     if (mode == 'horizontal')
1874       return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
1875         element.offsetWidth;
1876   },
1877
1878   clone: function(source, target) {
1879     source = $(source);
1880     target = $(target);
1881     target.style.position = 'absolute';
1882     var offsets = this.cumulativeOffset(source);
1883     target.style.top    = offsets[1] + 'px';
1884     target.style.left   = offsets[0] + 'px';
1885     target.style.width  = source.offsetWidth + 'px';
1886     target.style.height = source.offsetHeight + 'px';
1887   },
1888
1889   page: function(forElement) {
1890     var valueT = 0, valueL = 0;
1891
1892     var element = forElement;
1893     do {
1894       valueT += element.offsetTop  || 0;
1895       valueL += element.offsetLeft || 0;
1896
1897       // Safari fix
1898       if (element.offsetParent==document.body)
1899         if (Element.getStyle(element,'position')=='absolute') break;
1900
1901     } while (element = element.offsetParent);
1902
1903     element = forElement;
1904     do {
1905       valueT -= element.scrollTop  || 0;
1906       valueL -= element.scrollLeft || 0;
1907     } while (element = element.parentNode);
1908
1909     return [valueL, valueT];
1910   },
1911
1912   clone: function(source, target) {
1913     var options = Object.extend({
1914       setLeft:    true,
1915       setTop:     true,
1916       setWidth:   true,
1917       setHeight:  true,
1918       offsetTop:  0,
1919       offsetLeft: 0
1920     }, arguments[2] || {})
1921
1922     // find page position of source
1923     source = $(source);
1924     var p = Position.page(source);
1925
1926     // find coordinate system to use
1927     target = $(target);
1928     var delta = [0, 0];
1929     var parent = null;
1930     // delta [0,0] will do fine with position: fixed elements,
1931     // position:absolute needs offsetParent deltas
1932     if (Element.getStyle(target,'position') == 'absolute') {
1933       parent = Position.offsetParent(target);
1934       delta = Position.page(parent);
1935     }
1936
1937     // correct by body offsets (fixes Safari)
1938     if (parent == document.body) {
1939       delta[0] -= document.body.offsetLeft;
1940       delta[1] -= document.body.offsetTop;
1941     }
1942
1943     // set position
1944     if(options.setLeft)   target.style.left  = (p[0] - delta[0] + options.offsetLeft) + 'px';
1945     if(options.setTop)    target.style.top   = (p[1] - delta[1] + options.offsetTop) + 'px';
1946     if(options.setWidth)  target.style.width = source.offsetWidth + 'px';
1947     if(options.setHeight) target.style.height = source.offsetHeight + 'px';
1948   },
1949
1950   absolutize: function(element) {
1951     element = $(element);
1952     if (element.style.position == 'absolute') return;
1953     Position.prepare();
1954
1955     var offsets = Position.positionedOffset(element);
1956     var top     = offsets[1];
1957     var left    = offsets[0];
1958     var width   = element.clientWidth;
1959     var height  = element.clientHeight;
1960
1961     element._originalLeft   = left - parseFloat(element.style.left  || 0);
1962     element._originalTop    = top  - parseFloat(element.style.top || 0);
1963     element._originalWidth  = element.style.width;
1964     element._originalHeight = element.style.height;
1965
1966     element.style.position = 'absolute';
1967     element.style.top    = top + 'px';;
1968     element.style.left   = left + 'px';;
1969     element.style.width  = width + 'px';;
1970     element.style.height = height + 'px';;
1971   },
1972
1973   relativize: function(element) {
1974     element = $(element);
1975     if (element.style.position == 'relative') return;
1976     Position.prepare();
1977
1978     element.style.position = 'relative';
1979     var top  = parseFloat(element.style.top  || 0) - (element._originalTop || 0);
1980     var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);
1981
1982     element.style.top    = top + 'px';
1983     element.style.left   = left + 'px';
1984     element.style.height = element._originalHeight;
1985     element.style.width  = element._originalWidth;
1986   }
1987 }
1988
1989 // Safari returns margins on body which is incorrect if the child is absolutely
1990 // positioned.  For performance reasons, redefine Position.cumulativeOffset for
1991 // KHTML/WebKit only.
1992 if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
1993   Position.cumulativeOffset = function(element) {
1994     var valueT = 0, valueL = 0;
1995     do {
1996       valueT += element.offsetTop  || 0;
1997       valueL += element.offsetLeft || 0;
1998       if (element.offsetParent == document.body)
1999         if (Element.getStyle(element, 'position') == 'absolute') break;
2000
2001       element = element.offsetParent;
2002     } while (element);
2003
2004     return [valueL, valueT];
2005   }
2006 }