public/lib/Prototype.js

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