[Sommaire] [Imprimer]

   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(element, name, observer, useCapture) {
1521               var element = $(element);
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(element, name, observer, useCapture) {
1533                     var element = $(element);
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  }