[Sommaire] [Imprimer]

   1  /*  Prototype JavaScript framework, version 1.4.0_pre2

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

   3   *

   4   *  THIS FILE IS AUTOMATICALLY GENERATED. When sending patches, please diff

   5   *  against the source tree, available from the Prototype darcs repository. 

   6   *

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

   8   *

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

  10   *

  11  /*--------------------------------------------------------------------------*/

  12  

  13  var Prototype = {

  14    Version: '1.4.0_pre2',

  15    emptyFunction: function() {}

  16  }

  17  

  18  var Class = {

  19    create: function() {

  20      return function() { 

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

  22      }

  23    }

  24  }

  25  

  26  var Abstract = new Object();

  27  

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

  29    for (property in source) {

  30      destination[property] = source[property];

  31    }

  32    return destination;

  33  }

  34  

  35  /*

  36  Object.prototype.extend = function(object) {

  37    return Object.extend.apply(this, [this, object]);

  38  }

  39  */
  40  
  41  Function.prototype.bind = function(object) {
  42    var __method = this;
  43    return function() {
  44      return __method.apply(object, arguments);
  45    }
  46  }
  47  
  48  Function.prototype.bindAsEventListener = function(object) {
  49    var __method = this;
  50    return function(event) {
  51      return __method.call(object, event || window.event);
  52    }
  53  }
  54  
  55  Number.prototype.toColorPart = function() {
  56    var digits = this.toString(16);
  57    if (this < 16) return '0' + digits;
  58    return digits;
  59  }
  60  
  61  var Try = {
  62    these: function() {
  63      var returnValue;
  64  
  65      for (var i = 0; i < arguments.length; i++) {
  66        var lambda = arguments[i];
  67        try {
  68          returnValue = lambda();
  69          break;
  70        } catch (e) {}
  71      }
  72  
  73      return returnValue;
  74    }
  75  }
  76  
  77  /*--------------------------------------------------------------------------*/

  78  
  79  var PeriodicalExecuter = Class.create();
  80  PeriodicalExecuter.prototype = {
  81    initialize: function(callback, frequency) {
  82      this.callback = callback;
  83      this.frequency = frequency;
  84      this.currentlyExecuting = false;
  85  
  86      this.registerCallback();
  87    },
  88  
  89    registerCallback: function() {
  90      setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  91    },
  92  
  93    onTimerEvent: function() {
  94      if (!this.currentlyExecuting) {
  95        try { 
  96          this.currentlyExecuting = true;
  97          this.callback(); 
  98        } finally { 
  99          this.currentlyExecuting = false;
 100        }
 101      }
 102    }
 103  }
 104  
 105  /*--------------------------------------------------------------------------*/

 106  
 107  function $() {
 108    var elements = new Array();
 109  
 110    for (var i = 0; i < arguments.length; i++) {
 111      var element = arguments[i];
 112      if (typeof element == 'string')
 113        element = document.getElementById(element);
 114  
 115      if (arguments.length == 1) 
 116        return element;
 117  
 118      elements.push(element);
 119    }
 120  
 121    return elements;
 122  }
 123  
 124  if (!Array.prototype.push) {
 125    Array.prototype.push = function() {
 126          var startLength = this.length;
 127          for (var i = 0; i < arguments.length; i++)
 128        this[startLength + i] = arguments[i];
 129        return this.length;
 130    }
 131  }
 132  
 133  if (!Function.prototype.apply) {
 134    // Based on code from http://www.youngpup.net/

 135    Function.prototype.apply = function(object, parameters) {
 136      var parameterStrings = new Array();
 137      if (!object)     object = window;
 138      if (!parameters) parameters = new Array();
 139      
 140      for (var i = 0; i < parameters.length; i++)
 141        parameterStrings[i] = 'parameters[' + i + ']';
 142      
 143      object.__apply__ = this;
 144      var result = eval('object.__apply__(' + 
 145        parameterStrings.join(', ') + ')');
 146      object.__apply__ = null;
 147      
 148      return result;
 149    }
 150  }
 151  
 152  Object.extend(String.prototype, {
 153    stripTags: function() {
 154      return this.replace(/<\/?[^>]+>/gi, '');
 155    },
 156  
 157    escapeHTML: function() {
 158      var div = document.createElement('div');
 159      var text = document.createTextNode(this);
 160      div.appendChild(text);
 161      return div.innerHTML;
 162    },
 163  
 164    unescapeHTML: function() {
 165      var div = document.createElement('div');
 166      div.innerHTML = this.stripTags();
 167      return div.childNodes[0].nodeValue;
 168    }
 169  });
 170  
 171  var Ajax = {
 172    getTransport: function() {
 173      return Try.these(
 174        function() {return new ActiveXObject('Msxml2.XMLHTTP')},
 175        function() {return new ActiveXObject('Microsoft.XMLHTTP')},
 176        function() {return new XMLHttpRequest()}
 177      ) || false;
 178    }
 179  }
 180  
 181  Ajax.Base = function() {};
 182  Ajax.Base.prototype = {
 183    setOptions: function(options) {
 184      this.options = {
 185        method:       'post',
 186        asynchronous: true,
 187        parameters:   ''
 188      }
 189      Object.extend(this.options, options || {});
 190    },
 191  
 192    responseIsSuccess: function() {
 193      return this.transport.status == undefined
 194          || this.transport.status == 0 
 195          || (this.transport.status >= 200 && this.transport.status < 300);
 196    },
 197  
 198    responseIsFailure: function() {
 199      return !this.responseIsSuccess();
 200    }
 201  }
 202  
 203  Ajax.Request = Class.create();
 204  Ajax.Request.Events = 
 205    ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
 206  
 207  Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
 208    initialize: function(url, options) {
 209      this.transport = Ajax.getTransport();
 210      this.setOptions(options);
 211      this.request(url);
 212    },
 213  
 214    request: function(url) {
 215      var parameters = this.options.parameters || '';
 216      if (parameters.length > 0) parameters += '&_=';
 217  
 218      try {
 219        if (this.options.method == 'get')
 220          url += '?' + parameters;
 221  
 222        this.transport.open(this.options.method, url,
 223          this.options.asynchronous);
 224  
 225        if (this.options.asynchronous) {
 226          this.transport.onreadystatechange = this.onStateChange.bind(this);
 227          setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10);
 228        }
 229  
 230        this.setRequestHeaders();
 231  
 232        var body = this.options.postBody ? this.options.postBody : parameters;
 233        this.transport.send(this.options.method == 'post' ? body : null);
 234  
 235      } catch (e) {
 236      }
 237    },
 238  
 239    setRequestHeaders: function() {
 240      var requestHeaders = 
 241        ['X-Requested-With', 'XMLHttpRequest',
 242         'X-Prototype-Version', Prototype.Version];
 243  
 244      if (this.options.method == 'post') {
 245        requestHeaders.push('Content-type', 
 246          'application/x-www-form-urlencoded');
 247  
 248        /* Force "Connection: close" for Mozilla browsers to work around

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

 250         * header. See Mozilla Bugzilla #246651. 

 251         */
 252        if (this.transport.overrideMimeType)
 253          requestHeaders.push('Connection', 'close');
 254      }
 255  
 256      if (this.options.requestHeaders)
 257        requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);
 258  
 259      for (var i = 0; i < requestHeaders.length; i += 2)
 260        this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);
 261    },
 262  
 263    onStateChange: function() {
 264      var readyState = this.transport.readyState;
 265      if (readyState != 1)
 266        this.respondToReadyState(this.transport.readyState);
 267    },
 268  
 269    respondToReadyState: function(readyState) {
 270      var event = Ajax.Request.Events[readyState];
 271  
 272      if (event == 'Complete')
 273        (this.options['on' + this.transport.status]
 274         || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
 275         || Prototype.emptyFunction)(this.transport);
 276  
 277      (this.options['on' + event] || Prototype.emptyFunction)(this.transport);
 278  
 279      /* Avoid memory leak in MSIE: clean up the oncomplete event handler */

 280      if (event == 'Complete')
 281        this.transport.onreadystatechange = Prototype.emptyFunction;
 282    }
 283  });
 284  
 285  Ajax.Updater = Class.create();
 286  Ajax.Updater.ScriptFragment = '(?:<script.*?>)((\n|.)*?)(?:<\/script>)';
 287  
 288  Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
 289    initialize: function(container, url, options) {
 290      this.containers = {
 291        success: container.success ? $(container.success) : $(container),
 292        failure: container.failure ? $(container.failure) :
 293          (container.success ? null : $(container))
 294      }
 295  
 296      this.transport = Ajax.getTransport();
 297      this.setOptions(options);
 298  
 299      var onComplete = this.options.onComplete || Prototype.emptyFunction;
 300      this.options.onComplete = (function() {
 301        this.updateContent();
 302        onComplete(this.transport);
 303      }).bind(this);
 304  
 305      this.request(url);
 306    },
 307  
 308    updateContent: function() {
 309      var receiver = this.responseIsSuccess() ?
 310        this.containers.success : this.containers.failure;
 311  
 312      var match    = new RegExp(Ajax.Updater.ScriptFragment, 'img');
 313      var response = this.transport.responseText.replace(match, '');
 314      var scripts  = this.transport.responseText.match(match);
 315  
 316      if (receiver) {
 317        if (this.options.insertion) {
 318          new this.options.insertion(receiver, response);
 319        } else {
 320          receiver.innerHTML = response;
 321        }
 322      }
 323  
 324      if (this.responseIsSuccess()) {
 325        if (this.onComplete)
 326          setTimeout((function() {this.onComplete(
 327            this.transport)}).bind(this), 10);
 328      }
 329  
 330      if (this.options.evalScripts && scripts) {
 331        match = new RegExp(Ajax.Updater.ScriptFragment, 'im');
 332        setTimeout((function() {
 333          for (var i = 0; i < scripts.length; i++)
 334            eval(scripts[i].match(match)[1]);
 335        }).bind(this), 10);
 336      }
 337    }
 338  });
 339  
 340  Ajax.PeriodicalUpdater = Class.create();
 341  Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
 342    initialize: function(container, url, options) {
 343      this.setOptions(options);
 344      this.onComplete = this.options.onComplete;
 345  
 346      this.frequency = (this.options.frequency || 2);
 347      this.decay = 1;
 348  
 349      this.updater = {};
 350      this.container = container;
 351      this.url = url;
 352  
 353      this.start();
 354    },
 355  
 356    start: function() {
 357      this.options.onComplete = this.updateComplete.bind(this);
 358      this.onTimerEvent();
 359    },
 360  
 361    stop: function() {
 362      this.updater.onComplete = undefined;
 363      clearTimeout(this.timer);
 364      (this.onComplete || Ajax.emptyFunction).apply(this, arguments);
 365    },
 366  
 367    updateComplete: function(request) {
 368      if (this.options.decay) {
 369        this.decay = (request.responseText == this.lastText ? 
 370          this.decay * this.options.decay : 1);
 371  
 372        this.lastText = request.responseText;
 373      }
 374      this.timer = setTimeout(this.onTimerEvent.bind(this), 
 375        this.decay * this.frequency * 1000);
 376    },
 377  
 378    onTimerEvent: function() {
 379      this.updater = new Ajax.Updater(this.container, this.url, this.options);
 380    }
 381  });
 382  
 383  document.getElementsByClassName = function(className) {
 384    var children = document.getElementsByTagName('*') || document.all;
 385    var elements = new Array();
 386    
 387    for (var i = 0; i < children.length; i++) {
 388      var child = children[i];
 389      var classNames = child.className.split(' ');
 390      for (var j = 0; j < classNames.length; j++) {
 391        if (classNames[j] == className) {
 392          elements.push(child);
 393          break;
 394        }
 395      }
 396    }
 397    
 398    return elements;
 399  }
 400  
 401  /*--------------------------------------------------------------------------*/

 402  
 403  if (!window.Element) {
 404    var Element = new Object();
 405  }
 406  
 407  Object.extend(Element, {
 408    toggle: function() {
 409      for (var i = 0; i < arguments.length; i++) {
 410        var element = $(arguments[i]);
 411        element.style.display = 
 412          (element.style.display == 'none' ? '' : 'none');
 413      }
 414    },
 415  
 416    hide: function() {
 417      for (var i = 0; i < arguments.length; i++) {
 418        var element = $(arguments[i]);
 419        element.style.display = 'none';
 420      }
 421    },
 422  
 423    show: function() {
 424      for (var i = 0; i < arguments.length; i++) {
 425        var element = $(arguments[i]);
 426        element.style.display = '';
 427      }
 428    },
 429  
 430    remove: function(element) {
 431      element = $(element);
 432      element.parentNode.removeChild(element);
 433    },
 434     
 435    getHeight: function(element) {
 436      element = $(element);
 437      return element.offsetHeight; 
 438    },
 439  
 440    hasClassName: function(element, className) {
 441      element = $(element);
 442      if (!element)
 443        return;
 444      var a = element.className.split(' ');
 445      for (var i = 0; i < a.length; i++) {
 446        if (a[i] == className)
 447          return true;
 448      }
 449      return false;
 450    },
 451  
 452    addClassName: function(element, className) {
 453      element = $(element);
 454      Element.removeClassName(element, className);
 455      element.className += ' ' + className;
 456    },
 457  
 458    removeClassName: function(element, className) {
 459      element = $(element);
 460      if (!element)
 461        return;
 462      var newClassName = '';
 463      var a = element.className.split(' ');
 464      for (var i = 0; i < a.length; i++) {
 465        if (a[i] != className) {
 466          if (i > 0)
 467            newClassName += ' ';
 468          newClassName += a[i];
 469        }
 470      }
 471      element.className = newClassName;
 472    },
 473    
 474    // removes whitespace-only text node children

 475    cleanWhitespace: function(element) {
 476      var element = $(element);
 477      for (var i = 0; i < element.childNodes.length; i++) {
 478        var node = element.childNodes[i];
 479        if (node.nodeType == 3 && !/\S/.test(node.nodeValue)) 
 480          Element.remove(node);
 481      }
 482    }
 483  });
 484  
 485  var Toggle = new Object();
 486  Toggle.display = Element.toggle;
 487  
 488  /*--------------------------------------------------------------------------*/

 489  
 490  Abstract.Insertion = function(adjacency) {
 491    this.adjacency = adjacency;
 492  }
 493  
 494  Abstract.Insertion.prototype = {
 495    initialize: function(element, content) {
 496      this.element = $(element);
 497      this.content = content;
 498      
 499      if (this.adjacency && this.element.insertAdjacentHTML) {
 500        this.element.insertAdjacentHTML(this.adjacency, this.content);
 501      } else {
 502        this.range = this.element.ownerDocument.createRange();
 503        if (this.initializeRange) this.initializeRange();
 504        this.fragment = this.range.createContextualFragment(this.content);
 505        this.insertContent();
 506      }
 507    }
 508  }
 509  
 510  var Insertion = new Object();
 511  
 512  Insertion.Before = Class.create();
 513  Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
 514    initializeRange: function() {
 515      this.range.setStartBefore(this.element);
 516    },
 517    
 518    insertContent: function() {
 519      this.element.parentNode.insertBefore(this.fragment, this.element);
 520    }
 521  });
 522  
 523  Insertion.Top = Class.create();
 524  Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
 525    initializeRange: function() {
 526      this.range.selectNodeContents(this.element);
 527      this.range.collapse(true);
 528    },
 529    
 530    insertContent: function() {  
 531      this.element.insertBefore(this.fragment, this.element.firstChild);
 532    }
 533  });
 534  
 535  Insertion.Bottom = Class.create();
 536  Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
 537    initializeRange: function() {
 538      this.range.selectNodeContents(this.element);
 539      this.range.collapse(this.element);
 540    },
 541    
 542    insertContent: function() {
 543      this.element.appendChild(this.fragment);
 544    }
 545  });
 546  
 547  Insertion.After = Class.create();
 548  Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
 549    initializeRange: function() {
 550      this.range.setStartAfter(this.element);
 551    },
 552    
 553    insertContent: function() {
 554      this.element.parentNode.insertBefore(this.fragment, 
 555        this.element.nextSibling);
 556    }
 557  });
 558  
 559  var Field = {
 560    clear: function() {
 561      for (var i = 0; i < arguments.length; i++)
 562        $(arguments[i]).value = '';
 563    },
 564  
 565    focus: function(element) {
 566      $(element).focus();
 567    },
 568    
 569    present: function() {
 570      for (var i = 0; i < arguments.length; i++)
 571        if ($(arguments[i]).value == '') return false;
 572      return true;
 573    },
 574    
 575    select: function(element) {
 576      $(element).select();
 577    },
 578     
 579    activate: function(element) {
 580      $(element).focus();
 581      $(element).select();
 582    }
 583  }
 584  
 585  /*--------------------------------------------------------------------------*/

 586  
 587  var Form = {
 588    serialize: function(form) {
 589      var elements = Form.getElements($(form));
 590      var queryComponents = new Array();
 591      
 592      for (var i = 0; i < elements.length; i++) {
 593        var queryComponent = Form.Element.serialize(elements[i]);
 594        if (queryComponent)
 595          queryComponents.push(queryComponent);
 596      }
 597      
 598      return queryComponents.join('&');
 599    },
 600    
 601    getElements: function(form) {
 602      var form = $(form);
 603      var elements = new Array();
 604  
 605      for (tagName in Form.Element.Serializers) {
 606        var tagElements = form.getElementsByTagName(tagName);
 607        for (var j = 0; j < tagElements.length; j++)
 608          elements.push(tagElements[j]);
 609      }
 610      return elements;
 611    },
 612    
 613    getInputs: function(form, typeName, name) {
 614      var form = $(form);
 615      var inputs = form.getElementsByTagName('input');
 616      
 617      if (!typeName && !name)
 618        return inputs;
 619        
 620      var matchingInputs = new Array();
 621      for (var i = 0; i < inputs.length; i++) {
 622        var input = inputs[i];
 623        if ((typeName && input.type != typeName) ||
 624            (name && input.name != name)) 
 625          continue;
 626        matchingInputs.push(input);
 627      }
 628  
 629      return matchingInputs;
 630    },
 631  
 632    disable: function(form) {
 633      var elements = Form.getElements(form);
 634      for (var i = 0; i < elements.length; i++) {
 635        var element = elements[i];
 636        element.blur();
 637        element.disabled = 'true';
 638      }
 639    },
 640  
 641    enable: function(form) {
 642      var elements = Form.getElements(form);
 643      for (var i = 0; i < elements.length; i++) {
 644        var element = elements[i];
 645        element.disabled = '';
 646      }
 647    },
 648  
 649    focusFirstElement: function(form) {
 650      var form = $(form);
 651      var elements = Form.getElements(form);
 652      for (var i = 0; i < elements.length; i++) {
 653        var element = elements[i];
 654        if (element.type != 'hidden' && !element.disabled) {
 655          Field.activate(element);
 656          break;
 657        }
 658      }
 659    },
 660  
 661    reset: function(form) {
 662      $(form).reset();
 663    }
 664  }
 665  
 666  Form.Element = {
 667    serialize: function(element) {
 668      var element = $(element);
 669      var method = element.tagName.toLowerCase();
 670      var parameter = Form.Element.Serializers[method](element);
 671      
 672      if (parameter)
 673        return encodeURIComponent(parameter[0]) + '=' + 
 674          encodeURIComponent(parameter[1]);                   
 675    },
 676    
 677    getValue: function(element) {
 678      var element = $(element);
 679      var method = element.tagName.toLowerCase();
 680      var parameter = Form.Element.Serializers[method](element);
 681      
 682      if (parameter) 
 683        return parameter[1];
 684    }
 685  }
 686  
 687  Form.Element.Serializers = {
 688    input: function(element) {
 689      switch (element.type.toLowerCase()) {
 690        case 'submit':
 691        case 'hidden':
 692        case 'password':
 693        case 'text':
 694          return Form.Element.Serializers.textarea(element);
 695        case 'checkbox':  
 696        case 'radio':
 697          return Form.Element.Serializers.inputSelector(element);
 698      }
 699      return false;
 700    },
 701  
 702    inputSelector: function(element) {
 703      if (element.checked)
 704        return [element.name, element.value];
 705    },
 706  
 707    textarea: function(element) {
 708      return [element.name, element.value];
 709    },
 710  
 711    select: function(element) {
 712      var value = '';
 713      if (element.type == 'select-one') {
 714        var index = element.selectedIndex;
 715        if (index >= 0)
 716          value = element.options[index].value || element.options[index].text;
 717      } else {
 718        value = new Array();
 719        for (var i = 0; i < element.length; i++) {
 720          var opt = element.options[i];
 721          if (opt.selected)
 722            value.push(opt.value || opt.text);
 723        }
 724      }
 725      return [element.name, value];
 726    }
 727  }
 728  
 729  /*--------------------------------------------------------------------------*/

 730  
 731  var $F = Form.Element.getValue;
 732  
 733  /*--------------------------------------------------------------------------*/

 734  
 735  Abstract.TimedObserver = function() {}
 736  Abstract.TimedObserver.prototype = {
 737    initialize: function(element, frequency, callback) {
 738      this.frequency = frequency;
 739      this.element   = $(element);
 740      this.callback  = callback;
 741      
 742      this.lastValue = this.getValue();
 743      this.registerCallback();
 744    },
 745    
 746    registerCallback: function() {
 747      setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
 748    },
 749    
 750    onTimerEvent: function() {
 751      var value = this.getValue();
 752      if (this.lastValue != value) {
 753        this.callback(this.element, value);
 754        this.lastValue = value;
 755      }
 756    }
 757  }
 758  
 759  Form.Element.Observer = Class.create();
 760  Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
 761    getValue: function() {
 762      return Form.Element.getValue(this.element);
 763    }
 764  });
 765  
 766  Form.Observer = Class.create();
 767  Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
 768    getValue: function() {
 769      return Form.serialize(this.element);
 770    }
 771  });
 772  
 773  /*--------------------------------------------------------------------------*/

 774  
 775  Abstract.EventObserver = function() {}
 776  Abstract.EventObserver.prototype = {
 777    initialize: function(element, callback) {
 778      this.element  = $(element);
 779      this.callback = callback;
 780      
 781      this.lastValue = this.getValue();
 782      if (this.element.tagName.toLowerCase() == 'form')
 783        this.registerFormCallbacks();
 784      else
 785        this.registerCallback(this.element);
 786    },
 787    
 788    onElementEvent: function() {
 789      var value = this.getValue();
 790      if (this.lastValue != value) {
 791        this.callback(this.element, value);
 792        this.lastValue = value;
 793      }
 794    },
 795    
 796    registerFormCallbacks: function() {
 797      var elements = Form.getElements(this.element);
 798      for (var i = 0; i < elements.length; i++)
 799        this.registerCallback(elements[i]);
 800    },
 801    
 802    registerCallback: function(element) {
 803      if (element.type) {
 804        switch (element.type.toLowerCase()) {
 805          case 'checkbox':  
 806          case 'radio':
 807            element.target = this;
 808            element.prev_onclick = element.onclick || Prototype.emptyFunction;
 809            element.onclick = function() {
 810              this.prev_onclick(); 
 811              this.target.onElementEvent();
 812            }
 813            break;
 814          case 'password':
 815          case 'text':
 816          case 'textarea':
 817          case 'select-one':
 818          case 'select-multiple':
 819            element.target = this;
 820            element.prev_onchange = element.onchange || Prototype.emptyFunction;
 821            element.onchange = function() {
 822              this.prev_onchange(); 
 823              this.target.onElementEvent();
 824            }
 825            break;
 826        }
 827      }    
 828    }
 829  }
 830  
 831  Form.Element.EventObserver = Class.create();
 832  Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
 833    getValue: function() {
 834      return Form.Element.getValue(this.element);
 835    }
 836  });
 837  
 838  Form.EventObserver = Class.create();
 839  Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
 840    getValue: function() {
 841      return Form.serialize(this.element);
 842    }
 843  });
 844  
 845  
 846  if (!window.Event) {
 847    var Event = new Object();
 848  }
 849  
 850  Object.extend(Event, {
 851    KEY_BACKSPACE: 8,
 852    KEY_TAB:       9,
 853    KEY_RETURN:   13,
 854    KEY_ESC:      27,
 855    KEY_LEFT:     37,
 856    KEY_UP:       38,
 857    KEY_RIGHT:    39,
 858    KEY_DOWN:     40,
 859    KEY_DELETE:   46,
 860  
 861    element: function(event) {
 862      return event.target || event.srcElement;
 863    },
 864  
 865    isLeftClick: function(event) {
 866      return (((event.which) && (event.which == 1)) ||
 867              ((event.button) && (event.button == 1)));
 868    },
 869  
 870    pointerX: function(event) {
 871      return event.pageX || (event.clientX + 
 872        (document.documentElement.scrollLeft || document.body.scrollLeft));
 873    },
 874  
 875    pointerY: function(event) {
 876      return event.pageY || (event.clientY + 
 877        (document.documentElement.scrollTop || document.body.scrollTop));
 878    },
 879  
 880    stop: function(event) {
 881      if (event.preventDefault) { 
 882        event.preventDefault(); 
 883        event.stopPropagation(); 
 884      } else {
 885        event.returnValue = false;
 886      }
 887    },
 888  
 889    // find the first node with the given tagName, starting from the

 890    // node the event was triggered on; traverses the DOM upwards

 891    findElement: function(event, tagName) {
 892      var element = Event.element(event);
 893      while (element.parentNode && (!element.tagName ||
 894          (element.tagName.toUpperCase() != tagName.toUpperCase())))
 895        element = element.parentNode;
 896      return element;
 897    },
 898  
 899    observers: false,
 900    
 901    _observeAndCache: function(element, name, observer, useCapture) {
 902      if (!this.observers) this.observers = [];
 903      if (element.addEventListener) {
 904        this.observers.push([element, name, observer, useCapture]);
 905        element.addEventListener(name, observer, useCapture);
 906      } else if (element.attachEvent) {
 907        this.observers.push([element, name, observer, useCapture]);
 908        element.attachEvent('on' + name, observer);
 909      }
 910    },
 911    
 912    unloadCache: function() {
 913      if (!Event.observers) return;
 914      for (var i = 0; i < Event.observers.length; i++) {
 915        Event.stopObserving.apply(this, Event.observers[i]);
 916        Event.observers[i][0] = null;
 917      }
 918      Event.observers = false;
 919    },
 920  
 921    observe: function(element, name, observer, useCapture) {
 922      var element = $(element);
 923      useCapture = useCapture || false;
 924      
 925      if (name == 'keypress' &&
 926          ((navigator.appVersion.indexOf('AppleWebKit') > 0) 
 927          || element.attachEvent))
 928        name = 'keydown';
 929      
 930      this._observeAndCache(element, name, observer, useCapture);
 931    },
 932  
 933    stopObserving: function(element, name, observer, useCapture) {
 934      var element = $(element);
 935      useCapture = useCapture || false;
 936      
 937      if (name == 'keypress' &&
 938          ((navigator.appVersion.indexOf('AppleWebKit') > 0) 
 939          || element.detachEvent))
 940        name = 'keydown';
 941      
 942      if (element.removeEventListener) {
 943        element.removeEventListener(name, observer, useCapture);
 944      } else if (element.detachEvent) {
 945        element.detachEvent('on' + name, observer);
 946      }
 947    }
 948  });
 949  
 950  /* prevent memory leaks in IE */

 951  Event.observe(window, 'unload', Event.unloadCache, false);
 952  
 953  var Position = {
 954  
 955    // set to true if needed, warning: firefox performance problems

 956    // NOT neeeded for page scrolling, only if draggable contained in

 957    // scrollable elements

 958    includeScrollOffsets: false, 
 959  
 960    // must be called before calling withinIncludingScrolloffset, every time the

 961    // page is scrolled

 962    prepare: function() {
 963      this.deltaX =  window.pageXOffset 
 964                  || document.documentElement.scrollLeft 
 965                  || document.body.scrollLeft 
 966                  || 0;
 967      this.deltaY =  window.pageYOffset 
 968                  || document.documentElement.scrollTop 
 969                  || document.body.scrollTop 
 970                  || 0;
 971    },
 972  
 973    realOffset: function(element) {
 974      var valueT = 0, valueL = 0;
 975      do {
 976        valueT += element.scrollTop  || 0;
 977        valueL += element.scrollLeft || 0; 
 978        element = element.parentNode;
 979      } while (element);
 980      return [valueL, valueT];
 981    },
 982  
 983    cumulativeOffset: function(element) {
 984      var valueT = 0, valueL = 0;
 985      do {
 986        valueT += element.offsetTop  || 0;
 987        valueL += element.offsetLeft || 0;
 988        element = element.offsetParent;
 989      } while (element);
 990      return [valueL, valueT];
 991    },
 992  
 993    // caches x/y coordinate pair to use with overlap

 994    within: function(element, x, y) {
 995      if (this.includeScrollOffsets)
 996        return this.withinIncludingScrolloffsets(element, x, y);
 997      this.xcomp = x;
 998      this.ycomp = y;
 999      this.offset = this.cumulativeOffset(element);
1000  
1001      return (y >= this.offset[1] &&
1002              y <  this.offset[1] + element.offsetHeight &&
1003              x >= this.offset[0] && 
1004              x <  this.offset[0] + element.offsetWidth);
1005    },
1006  
1007    withinIncludingScrolloffsets: function(element, x, y) {
1008      var offsetcache = this.realOffset(element);
1009  
1010      this.xcomp = x + offsetcache[0] - this.deltaX;
1011      this.ycomp = y + offsetcache[1] - this.deltaY;
1012      this.offset = this.cumulativeOffset(element);
1013  
1014      return (this.ycomp >= this.offset[1] &&
1015              this.ycomp <  this.offset[1] + element.offsetHeight &&
1016              this.xcomp >= this.offset[0] && 
1017              this.xcomp <  this.offset[0] + element.offsetWidth);
1018    },
1019  
1020    // within must be called directly before

1021    overlap: function(mode, element) {  
1022      if (!mode) return 0;  
1023      if (mode == 'vertical') 
1024        return ((this.offset[1] + element.offsetHeight) - this.ycomp) / 
1025          element.offsetHeight;
1026      if (mode == 'horizontal')
1027        return ((this.offset[0] + element.offsetWidth) - this.xcomp) / 
1028          element.offsetWidth;
1029    },
1030  
1031    clone: function(source, target) {
1032      source = $(source);
1033      target = $(target);
1034      target.style.position = 'absolute';
1035      var offsets = this.cumulativeOffset(source);
1036      target.style.top    = offsets[1] + 'px';
1037      target.style.left   = offsets[0] + 'px';
1038      target.style.width  = source.offsetWidth + 'px';
1039      target.style.height = source.offsetHeight + 'px';
1040    }
1041  }