Changeset 43

Show
Ignore:
Timestamp:
12/29/06 09:38:34 (2 years ago)
Author:
bermiferrer
Message:

Updating prototype.js version

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/public/javascripts/prototype.js

    r2 r43  
    1 /*  Prototype JavaScript framework, version 1.5.0_pre
     1/*  Prototype JavaScript framework, version 1.5.0_rc
    22 *  (c) 2005 Sam Stephenson <sam@conio.net> 
    33 * 
     
    88 
    99var Prototype = { 
    10   Version: '1.5.0_pre1', 
     10  Version: '1.5.0_rc1', 
    1111  ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)', 
    1212 
     
    2626 
    2727Object.extend = function(destination, source) { 
    28   for (property in source) { 
     28  for (var property in source) { 
    2929    destination[property] = source[property]; 
    3030  } 
     
    3232} 
    3333 
    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 
     34Object.extend(Object, { 
     35  inspect: function(object) { 
     36    try { 
     37      if (object == undefined) return 'undefined'; 
     38      if (object == null) return 'null'; 
     39      return object.inspect ? object.inspect() : object.toString(); 
     40    } catch (e) { 
     41      if (e instanceof RangeError) return '...'; 
     42      throw e; 
     43    } 
     44  }, 
     45 
     46  keys: function(object) { 
     47    var keys = []; 
     48    for (var property in object) 
     49      keys.push(property); 
     50    return keys; 
     51  }, 
     52 
     53  values: function(object) { 
     54    var values = []; 
     55    for (var property in object) 
     56      values.push(object[property]); 
     57    return values; 
     58  }, 
     59 
     60  clone: function(object) { 
     61    return Object.extend({}, object); 
     62  } 
     63}); 
    4464 
    4565Function.prototype.bind = function() { 
     
    5171 
    5272Function.prototype.bindAsEventListener = function(object) { 
    53   var __method = this
     73  var __method = this, args = $A(arguments), object = args.shift()
    5474  return function(event) { 
    55     return __method.call(object, event || window.event); 
     75    return __method.apply(object, [( event || window.event)].concat(args).concat($A(arguments))); 
    5676  } 
    5777} 
     
    103123 
    104124  registerCallback: function() { 
    105     setInterval(this.onTimerEvent.bind(this), this.frequency * 1000); 
     125    this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000); 
     126  }, 
     127 
     128  stop: function() { 
     129    if (!this.timer) return; 
     130    clearInterval(this.timer); 
     131    this.timer = null; 
    106132  }, 
    107133 
     
    110136      try { 
    111137        this.currentlyExecuting = true; 
    112         this.callback(); 
     138        this.callback(this); 
    113139      } finally { 
    114140        this.currentlyExecuting = false; 
     
    177203 
    178204  evalScripts: function() { 
    179     return this.extractScripts().map(eval); 
     205    return this.extractScripts().map(function(script) { return eval(script) }); 
    180206  }, 
    181207 
     
    196222    var pairs = this.match(/^\??(.*)$/)[1].split('&'); 
    197223    return pairs.inject({}, function(params, pairString) { 
    198       var pair = pairString.split('='); 
    199       params[pair[0]] = pair[1]; 
     224      var pair  = pairString.split('='); 
     225      var value = pair[1] ? decodeURIComponent(pair[1]) : undefined; 
     226      params[decodeURIComponent(pair[0])] = value; 
    200227      return params; 
    201228    }); 
     
    222249  }, 
    223250 
    224   inspect: function() { 
    225     return "'" + this.replace(/\\/g, '\\\\').replace(/'/g, '\\\'') + "'"; 
     251  inspect: function(useDoubleQuotes) { 
     252    var escapedString = this.replace(/\\/g, '\\\\'); 
     253    if (useDoubleQuotes) 
     254      return '"' + escapedString.replace(/"/g, '\\"') + '"'; 
     255    else 
     256      return "'" + escapedString.replace(/'/g, '\\\'') + "'"; 
    226257  } 
    227258}); 
     
    281312 
    282313  any: function(iterator) { 
    283     var result = true; 
     314    var result = false; 
    284315    this.each(function(value, index) { 
    285316      if (result = !!(iterator || Prototype.K)(value, index)) 
     
    356387    this.each(function(value, index) { 
    357388      value = (iterator || Prototype.K)(value, index); 
    358       if (value >= (result || value)
     389      if (result == undefined || value >= result
    359390        result = value; 
    360391    }); 
     
    366397    this.each(function(value, index) { 
    367398      value = (iterator || Prototype.K)(value, index); 
    368       if (value <= (result || value)
     399      if (result == undefined || value < result
    369400        result = value; 
    370401    }); 
     
    448479Object.extend(Array.prototype, Enumerable); 
    449480 
    450 Array.prototype._reverse = Array.prototype.reverse; 
     481if (!Array.prototype._reverse) 
     482  Array.prototype._reverse = Array.prototype.reverse; 
    451483 
    452484Object.extend(Array.prototype, { 
     
    477509  flatten: function() { 
    478510    return this.inject([], function(array, value) { 
    479       return array.concat(value.constructor == Array ? 
     511      return array.concat(value && value.constructor == Array ? 
    480512        value.flatten() : [value]); 
    481513    }); 
     
    499531  }, 
    500532 
    501   shift: function() { 
    502     var result = this[0]; 
    503     for (var i = 0; i < this.length - 1; i++) 
    504       this[i] = this[i + 1]; 
    505     this.length--; 
    506     return result; 
     533  reduce: function() { 
     534    return this.length > 1 ? this : this[0]; 
     535  }, 
     536 
     537  uniq: function() { 
     538    return this.inject([], function(array, value) { 
     539      return array.include(value) ? array : array.concat([value]); 
     540    }); 
    507541  }, 
    508542 
     
    513547var Hash = { 
    514548  _each: function(iterator) { 
    515     for (key in this) { 
     549    for (var key in this) { 
    516550      var value = this[key]; 
    517551      if (typeof value == 'function') continue; 
     
    569603  _each: function(iterator) { 
    570604    var value = this.start; 
    571     do
     605    while (this.include(value))
    572606      iterator(value); 
    573607      value = value.succ(); 
    574     } while (this.include(value)); 
     608    } 
    575609  }, 
    576610 
     
    591625  getTransport: function() { 
    592626    return Try.these( 
     627      function() {return new XMLHttpRequest()}, 
    593628      function() {return new ActiveXObject('Msxml2.XMLHTTP')}, 
    594       function() {return new ActiveXObject('Microsoft.XMLHTTP')}, 
    595       function() {return new XMLHttpRequest()} 
     629      function() {return new ActiveXObject('Microsoft.XMLHTTP')} 
    596630    ) || false; 
    597631  }, 
     
    645679      method:       'post', 
    646680      asynchronous: true, 
     681      contentType:  'application/x-www-form-urlencoded', 
    647682      parameters:   '' 
    648683    } 
     
    676711    if (parameters.length > 0) parameters += '&_='; 
    677712 
     713    /* Simulate other verbs over post */ 
     714    if (this.options.method != 'get' && this.options.method != 'post') { 
     715      parameters += (parameters.length > 0 ? '&' : '') + '_method=' + this.options.method; 
     716      this.options.method = 'post'; 
     717    } 
     718 
    678719    try { 
    679720      this.url = url; 
     
    686727        this.options.asynchronous); 
    687728 
    688       if (this.options.asynchronous) { 
    689         this.transport.onreadystatechange = this.onStateChange.bind(this); 
    690         setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10); 
    691       } 
    692  
     729      if (this.options.asynchronous) 
     730        setTimeout(function() { this.respondToReadyState(1) }.bind(this), 10); 
     731 
     732      this.transport.onreadystatechange = this.onStateChange.bind(this); 
    693733      this.setRequestHeaders(); 
    694734 
    695735      var body = this.options.postBody ? this.options.postBody : parameters; 
    696736      this.transport.send(this.options.method == 'post' ? body : null); 
     737 
     738      /* Force Firefox to handle ready state 4 for synchronous requests */ 
     739      if (!this.options.asynchronous && this.transport.overrideMimeType) 
     740        this.onStateChange(); 
    697741 
    698742    } catch (e) { 
     
    708752 
    709753    if (this.options.method == 'post') { 
    710       requestHeaders.push('Content-type', 
    711         'application/x-www-form-urlencoded'); 
     754      requestHeaders.push('Content-type', this.options.contentType); 
    712755 
    713756      /* Force "Connection: close" for Mozilla browsers to work around 
     
    740783  evalJSON: function() { 
    741784    try { 
    742       return eval(this.header('X-JSON')); 
     785      return eval('(' + this.header('X-JSON') + ')'); 
    743786    } catch (e) {} 
    744787  }, 
     
    854897 
    855898  stop: function() { 
    856     this.updater.onComplete = undefined; 
     899    this.updater.options.onComplete = undefined; 
    857900    clearTimeout(this.timer); 
    858901    (this.onComplete || Prototype.emptyFunction).apply(this, arguments); 
     
    882925    results.push(Element.extend(element)); 
    883926  } 
    884   return results.length < 2 ? results[0] : results
     927  return results.reduce()
    885928} 
    886929 
     
    901944Element.extend = function(element) { 
    902945  if (!element) return; 
     946  if (_nativeExtensions || element.nodeType == 3) return element; 
    903947 
    904948  if (!element._extended && element.tagName && element != window) { 
    905     var methods = Element.Methods; 
    906     for (property in methods) { 
     949    var methods = Object.clone(Element.Methods), cache = Element.extend.cache; 
     950 
     951    if (element.tagName == 'FORM') 
     952      Object.extend(methods, Form.Methods); 
     953    if (['INPUT', 'TEXTAREA', 'SELECT'].include(element.tagName)) 
     954      Object.extend(methods, Form.Element.Methods); 
     955 
     956    for (var property in methods) { 
    907957      var value = methods[property]; 
    908958      if (typeof value == 'function') 
    909         element[property] = value.bind(null, element); 
     959        element[property] = cache.findOrStore(value); 
    910960    } 
    911961  } 
     
    913963  element._extended = true; 
    914964  return element; 
     965} 
     966 
     967Element.extend.cache = { 
     968  findOrStore: function(value) { 
     969    return this[value] = this[value] || function() { 
     970      return value.apply(null, [this].concat($A(arguments))); 
     971    } 
     972  } 
    915973} 
    916974 
     
    920978  }, 
    921979 
    922   toggle: function() { 
    923     for (var i = 0; i < arguments.length; i++) { 
    924       var element = $(arguments[i]); 
    925       Element[Element.visible(element) ? 'hide' : 'show'](element); 
    926     } 
    927   }, 
    928  
    929   hide: function() { 
    930     for (var i = 0; i < arguments.length; i++) { 
    931       var element = $(arguments[i]); 
    932       element.style.display = 'none'; 
    933     } 
    934   }, 
    935  
    936   show: function() { 
    937     for (var i = 0; i < arguments.length; i++) { 
    938       var element = $(arguments[i]); 
    939       element.style.display = ''; 
    940     } 
     980  toggle: function(element) { 
     981    element = $(element); 
     982    Element[Element.visible(element) ? 'hide' : 'show'](element); 
     983    return element; 
     984  }, 
     985 
     986  hide: function(element) { 
     987    $(element).style.display = 'none'; 
     988    return element; 
     989  }, 
     990 
     991  show: function(element) { 
     992    $(element).style.display = ''; 
     993    return element; 
    941994  }, 
    942995 
     
    944997    element = $(element); 
    945998    element.parentNode.removeChild(element); 
     999    return element; 
    9461000  }, 
    9471001 
     
    9491003    $(element).innerHTML = html.stripScripts(); 
    9501004    setTimeout(function() {html.evalScripts()}, 10); 
     1005    return element; 
    9511006  }, 
    9521007 
     
    9621017    } 
    9631018    setTimeout(function() {html.evalScripts()}, 10); 
     1019    return element; 
     1020  }, 
     1021 
     1022  inspect: function(element) { 
     1023    element = $(element); 
     1024    var result = '<' + element.tagName.toLowerCase(); 
     1025    $H({'id': 'id', 'className': 'class'}).each(function(pair) { 
     1026      var property = pair.first(), attribute = pair.last(); 
     1027      var value = (element[property] || '').toString(); 
     1028      if (value) result += ' ' + attribute + '=' + value.inspect(true); 
     1029    }); 
     1030    return result + '>'; 
     1031  }, 
     1032 
     1033  recursivelyCollect: function(element, property) { 
     1034    element = $(element); 
     1035    var elements = []; 
     1036    while (element = element[property]) 
     1037      if (element.nodeType == 1) 
     1038        elements.push(Element.extend(element)); 
     1039    return elements; 
     1040  }, 
     1041 
     1042  ancestors: function(element) { 
     1043    return $(element).recursivelyCollect('parentNode'); 
     1044  }, 
     1045 
     1046  descendants: function(element) { 
     1047    element = $(element); 
     1048    return $A(element.getElementsByTagName('*')); 
     1049  }, 
     1050 
     1051  previousSiblings: function(element) { 
     1052    return $(element).recursivelyCollect('previousSibling'); 
     1053  }, 
     1054 
     1055  nextSiblings: function(element) { 
     1056    return $(element).recursivelyCollect('nextSibling'); 
     1057  }, 
     1058 
     1059  siblings: function(element) { 
     1060    element = $(element); 
     1061    return element.previousSiblings().reverse().concat(element.nextSiblings()); 
     1062  }, 
     1063 
     1064  match: function(element, selector) { 
     1065    element = $(element); 
     1066    if (typeof selector == 'string') 
     1067      selector = new Selector(selector); 
     1068    return selector.match(element); 
     1069  }, 
     1070 
     1071  up: function(element, expression, index) { 
     1072    return Selector.findElement($(element).ancestors(), expression, index); 
     1073  }, 
     1074 
     1075  down: function(element, expression, index) { 
     1076    return Selector.findElement($(element).descendants(), expression, index); 
     1077  }, 
     1078 
     1079  previous: function(element, expression, index) { 
     1080    return Selector.findElement($(element).previousSiblings(), expression, index); 
     1081  }, 
     1082 
     1083  next: function(element, expression, index) { 
     1084    return Selector.findElement($(element).nextSiblings(), expression, index); 
     1085  }, 
     1086 
     1087  getElementsBySelector: function() { 
     1088    var args = $A(arguments), element = $(args.shift()); 
     1089    return Selector.findChildElements(element, args); 
     1090  }, 
     1091 
     1092  getElementsByClassName: function(element, className) { 
     1093    element = $(element); 
     1094    return document.getElementsByClassName(className, element); 
    9641095  }, 
    9651096 
     
    9801111  addClassName: function(element, className) { 
    9811112    if (!(element = $(element))) return; 
    982     return Element.classNames(element).add(className); 
     1113    Element.classNames(element).add(className); 
     1114    return element; 
    9831115  }, 
    9841116 
    9851117  removeClassName: function(element, className) { 
    9861118    if (!(element = $(element))) return; 
    987     return Element.classNames(element).remove(className); 
     1119    Element.classNames(element).remove(className); 
     1120    return element; 
     1121  }, 
     1122 
     1123  observe: function() { 
     1124    Event.observe.apply(Event, arguments); 
     1125    return $A(arguments).first(); 
     1126  }, 
     1127 
     1128  stopObserving: function() { 
     1129    Event.stopObserving.apply(Event, arguments); 
     1130    return $A(arguments).first(); 
    9881131  }, 
    9891132 
     
    9911134  cleanWhitespace: function(element) { 
    9921135    element = $(element); 
    993     for (var i = 0; i < element.childNodes.length; i++) { 
    994       var node = element.childNodes[i]; 
     1136    var node = element.firstChild; 
     1137    while (node) { 
     1138      var nextNode = node.nextSibling; 
    9951139      if (node.nodeType == 3 && !/\S/.test(node.nodeValue)) 
    996         Element.remove(node); 
    997     } 
     1140        element.removeChild(node); 
     1141      node = nextNode; 
     1142    } 
     1143    return element; 
    9981144  }, 
    9991145 
     
    10111157  scrollTo: function(element) { 
    10121158    element = $(element); 
    1013     var x = element.x ? element.x : element.offsetLeft, 
    1014         y = element.y ? element.y : element.offsetTop; 
    1015     window.scrollTo(x, y)
     1159    var pos = Position.cumulativeOffset(element); 
     1160    window.scrollTo(pos[0], pos[1]);  
     1161    return element
    10161162  }, 
    10171163 
     
    10361182  setStyle: function(element, style) { 
    10371183    element = $(element); 
    1038     for (name in style) 
     1184    for (var name in style) 
    10391185      element.style[name.camelize()] = style[name]; 
     1186    return element; 
    10401187  }, 
    10411188 
     
    10741221      } 
    10751222    } 
     1223    return element; 
    10761224  }, 
    10771225 
     
    10861234        element.style.right = ''; 
    10871235    } 
     1236    return element; 
    10881237  }, 
    10891238 
     
    10911240    element = $(element); 
    10921241    if (element._overflow) return; 
    1093     element._overflow = element.style.overflow
     1242    element._overflow = element.style.overflow || 'auto'
    10941243    if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden') 
    10951244      element.style.overflow = 'hidden'; 
     1245    return element; 
    10961246  }, 
    10971247 
    10981248  undoClipping: function(element) { 
    10991249    element = $(element); 
    1100     if (element._overflow) return; 
    1101     element.style.overflow = element._overflow; 
    1102     element._overflow = undefined; 
     1250    if (!element._overflow) return; 
     1251    element.style.overflow = element._overflow == 'auto' ? '' : element._overflow; 
     1252    element._overflow = null; 
     1253    return element; 
     1254  } 
     1255
     1256 
     1257// IE is missing .innerHTML support for TABLE-related elements 
     1258if(document.all){ 
     1259  Element.Methods.update = function(element, html) { 
     1260    element = $(element); 
     1261    var tagName = element.tagName.toUpperCase(); 
     1262    if (['THEAD','TBODY','TR','TD'].indexOf(tagName) > -1) { 
     1263      var div = document.createElement('div'); 
     1264      switch (tagName) { 
     1265        case 'THEAD': 
     1266        case 'TBODY': 
     1267          div.innerHTML = '<table><tbody>' +  html.stripScripts() + '</tbody></table>'; 
     1268          depth = 2; 
     1269          break; 
     1270        case 'TR': 
     1271          div.innerHTML = '<table><tbody><tr>' +  html.stripScripts() + '</tr></tbody></table>'; 
     1272          depth = 3; 
     1273          break; 
     1274        case 'TD': 
     1275          div.innerHTML = '<table><tbody><tr><td>' +  html.stripScripts() + '</td></tr></tbody></table>'; 
     1276          depth = 4; 
     1277      } 
     1278      $A(element.childNodes).each(function(node){ 
     1279        element.removeChild(node) 
     1280      }); 
     1281      depth.times(function(){ div = div.firstChild }); 
     1282 
     1283      $A(div.childNodes).each( 
     1284        function(node){ element.appendChild(node) }); 
     1285    } else { 
     1286      element.innerHTML = html.stripScripts(); 
     1287    } 
     1288    setTimeout(function() {html.evalScripts()}, 10); 
     1289    return element; 
    11031290  } 
    11041291} 
    11051292 
    11061293Object.extend(Element, Element.Methods); 
     1294 
     1295var _nativeExtensions = false; 
     1296 
     1297if (!window.HTMLElement && /Konqueror|Safari|KHTML/.test(navigator.userAgent)) { 
     1298  /* Emulate HTMLElement, HTMLFormElement, HTMLInputElement, HTMLTextAreaElement, 
     1299     and HTMLSelectElement in Safari */ 
     1300  ['', 'Form', 'Input', 'TextArea', 'Select'].each(function(tag) { 
     1301    var klass = window['HTML' + tag + 'Element'] = {}; 
     1302    klass.prototype = document.createElement(tag ? tag.toLowerCase() : 'div').__proto__; 
     1303  }); 
     1304} 
     1305 
     1306Element.addMethods = function(methods) { 
     1307  Object.extend(Element.Methods, methods || {}); 
     1308 
     1309  function copy(methods, destination) { 
     1310    var cache = Element.extend.cache; 
     1311    for (var property in methods) { 
     1312      var value = methods[property]; 
     1313      destination[property] = cache.findOrStore(value); 
     1314    } 
     1315  } 
     1316 
     1317  if (typeof HTMLElement != 'undefined') { 
     1318    copy(Element.Methods, HTMLElement.prototype); 
     1319    copy(Form.Methods, HTMLFormElement.prototype); 
     1320    [HTMLInputElement, HTMLTextAreaElement, HTMLSelectElement].each(function(klass) { 
     1321      copy(Form.Element.Methods, klass.prototype); 
     1322    }); 
     1323    _nativeExtensions = true; 
     1324  } 
     1325} 
    11071326 
    11081327var Toggle = new Object(); 
     
    11241343        this.element.insertAdjacentHTML(this.adjacency, this.content); 
    11251344      } catch (e) { 
    1126         if (this.element.tagName.toLowerCase() == 'tbody') { 
     1345        var tagName = this.element.tagName.toLowerCase(); 
     1346        if (tagName == 'tbody' || tagName == 'tr') { 
    11271347          this.insertContent(this.contentFromAnonymousTable()); 
    11281348        } else { 
     
    13411561} 
    13421562 
     1563Object.extend(Selector, { 
     1564  matchElements: function(elements, expression) { 
     1565    var selector = new Selector(expression); 
     1566    return elements.select(selector.match.bind(selector)); 
     1567  }, 
     1568 
     1569  findElement: function(elements, expression, index) { 
     1570    if (typeof expression == 'number') index = expression, expression = false; 
     1571    return Selector.matchElements(elements, expression || '*')[index || 0]; 
     1572  }, 
     1573 
     1574  findChildElements: function(element, expressions) { 
     1575    return expressions.map(function(expression) { 
     1576      return expression.strip().split(/\s+/).inject([null], function(results, expr) { 
     1577        var selector = new Selector(expr); 
     1578        return results.inject([], function(elements, result) { 
     1579          return elements.concat(selector.findElements(result || element)); 
     1580        }); 
     1581      }); 
     1582    }).flatten(); 
     1583  } 
     1584}); 
     1585 
    13431586function $$() { 
    1344   return $A(arguments).map(function(expression) { 
    1345     return expression.strip().split(/\s+/).inject([null], function(results, expr) { 
    1346       var selector = new Selector(expr); 
    1347       return results.map(selector.findElements.bind(selector)).flatten(); 
    1348     }); 
    1349   }).flatten(); 
    1350 
    1351 var Field = { 
    1352   clear: function() { 
    1353     for (var i = 0; i < arguments.length; i++) 
    1354       $(arguments[i]).value = ''; 
    1355   }, 
    1356  
    1357   focus: function(element) { 
    1358     $(element).focus(); 
    1359   }, 
    1360  
    1361   present: function() { 
    1362     for (var i = 0; i < arguments.length; i++) 
    1363       if ($(arguments[i]).value == '') return false; 
    1364     return true; 
    1365   }, 
    1366  
    1367   select: function(element) { 
    1368     $(element).select(); 
    1369   }, 
    1370  
    1371   activate: function(element) { 
    1372     element = $(element); 
    1373     element.focus(); 
    1374     if (element.select) 
    1375       element.select(); 
    1376   } 
    1377 
    1378  
    1379 /*--------------------------------------------------------------------------*/ 
    1380  
     1587  return Selector.findChildElements(document, $A(arguments)); 
     1588
    13811589var Form = { 
     1590  reset: function(form) { 
     1591    $(form).reset(); 
     1592    return form; 
     1593  } 
     1594}; 
     1595 
     1596Form.Methods = { 
    13821597  serialize: function(form) { 
    13831598    var elements = Form.getElements($(form)); 
     
    13971612    var elements = new Array(); 
    13981613 
    1399     for (tagName in Form.Element.Serializers) { 
     1614    for (var tagName in Form.Element.Serializers) { 
    14001615      var tagElements = form.getElementsByTagName(tagName); 
    14011616      for (var j = 0; j < tagElements.length; j++) 
     
    14251640 
    14261641  disable: function(form) { 
     1642    form = $(form); 
    14271643    var elements = Form.getElements(form); 
    14281644    for (var i = 0; i < elements.length; i++) { 
     
    14311647      element.disabled = 'true'; 
    14321648    } 
     1649    return form; 
    14331650  }, 
    14341651 
    14351652  enable: function(form) { 
     1653    form = $(form); 
    14361654    var elements = Form.getElements(form); 
    14371655    for (var i = 0; i < elements.length; i++) { 
     
    14391657      element.disabled = ''; 
    14401658    } 
     1659    return form; 
    14411660  }, 
    14421661 
     
    14491668 
    14501669  focusFirstElement: function(form) { 
     1670    form = $(form); 
    14511671    Field.activate(Form.findFirstElement(form)); 
    1452   }, 
    1453  
    1454   reset: function(form) { 
    1455     $(form).reset(); 
    1456   } 
    1457 
     1672    return form; 
     1673  } 
     1674
     1675 
     1676Object.extend(Form, Form.Methods); 
     1677 
     1678/*--------------------------------------------------------------------------*/ 
    14581679 
    14591680Form.Element = { 
     1681  focus: function(element) { 
     1682    $(element).focus(); 
     1683    return element; 
     1684  }, 
     1685 
     1686  select: function(element) { 
     1687    $(element).select(); 
     1688    return element; 
     1689  } 
     1690} 
     1691 
     1692Form.Element.Methods = { 
    14601693  serialize: function(element) { 
    14611694    element = $(element); 
     
    14831716    if (parameter) 
    14841717      return parameter[1]; 
    1485   } 
    1486 
     1718  }, 
     1719 
     1720  clear: function(element) { 
     1721    $(element).value = ''; 
     1722    return element; 
     1723  }, 
     1724 
     1725  present: function(element) { 
     1726    return $(element).value != ''; 
     1727  }, 
     1728 
     1729  activate: function(element) { 
     1730    element = $(element); 
     1731    element.focus(); 
     1732    if (element.select) 
     1733      element.select(); 
     1734    return element; 
     1735  }, 
     1736 
     1737  disable: function(element) { 
     1738    element = $(element); 
     1739    element.disabled = ''; 
     1740    return element; 
     1741  }, 
     1742 
     1743  enable: function(element) { 
     1744    element = $(element); 
     1745    element.blur(); 
     1746    element.disabled = 'true'; 
     1747    return element; 
     1748  } 
     1749
     1750 
     1751Object.extend(Form.Element, Form.Element.Methods); 
     1752var Field = Form.Element; 
     1753 
     1754/*--------------------------------------------------------------------------*/ 
    14871755 
    14881756Form.Element.Serializers = { 
    14891757  input: function(element) { 
    14901758    switch (element.type.toLowerCase()) { 
    1491       case 'submit': 
    1492       case 'hidden': 
    1493       case 'password': 
    1494       case 'text': 
    1495         return Form.Element.Serializers.textarea(element); 
    14961759      case 'checkbox': 
    14971760      case 'radio': 
    14981761        return Form.Element.Serializers.inputSelector(element); 
     1762      default: 
     1763        return Form.Element.Serializers.textarea(element); 
    14991764    } 
    15001765    return false; 
     
    15191784    if (index >= 0) { 
    15201785      opt = element.options[index]; 
    1521       value = opt.value; 
    1522       if (!value && !('value' in opt)) 
    1523         value = opt.text; 
     1786      value = opt.value || opt.text; 
    15241787    } 
    15251788    return [element.name, value]; 
     
    15271790 
    15281791  selectMany: function(element) { 
    1529     var value = new Array()
     1792    var value = []
    15301793    for (var i = 0; i < element.length; i++) { 
    15311794      var opt = element.options[i]; 
    1532       if (opt.selected) { 
    1533         var optValue = opt.value; 
    1534         if (!optValue && !('value' in opt)) 
    1535           optValue = opt.text; 
    1536         value.push(optValue); 
    1537       } 
     1795      if (opt.selected) 
     1796        value.push(opt.value || opt.text); 
    15381797    } 
    15391798    return [element.name, value]; 
     
    16211880          Event.observe(element, 'click', this.onElementEvent.bind(this)); 
    16221881          break; 
    1623         case 'password': 
    1624         case 'text': 
    1625         case 'textarea': 
    1626         case 'select-one': 
    1627         case 'select-multiple': 
     1882        default: 
    16281883          Event.observe(element, 'change', this.onElementEvent.bind(this)); 
    16291884          break; 
     
    16601915  KEY_DOWN:     40, 
    16611916  KEY_DELETE:   46, 
     1917  KEY_HOME:     36, 
     1918  KEY_END:      35, 
     1919  KEY_PAGEUP:   33, 
     1920  KEY_PAGEDOWN: 34, 
    16621921 
    16631922  element: function(event) { 
     
    17231982 
    17241983  observe: function(element, name, observer, useCapture) { 
    1725     var element = $(element); 
     1984    element = $(element); 
    17261985    useCapture = useCapture || false; 
    17271986 
     
    17311990      name = 'keydown'; 
    17321991 
    1733     this._observeAndCache(element, name, observer, useCapture); 
     1992    Event._observeAndCache(element, name, observer, useCapture); 
    17341993  }, 
    17351994 
    17361995  stopObserving: function(element, name, observer, useCapture) { 
    1737     var element = $(element); 
     1996    element = $(element); 
    17381997    useCapture = useCapture || false; 
    17391998 
     
    17462005      element.removeEventListener(name, observer, useCapture); 
    17472006    } else if (element.detachEvent) { 
    1748       element.detachEvent('on' + name, observer); 
     2007      try { 
     2008        element.detachEvent('on' + name, observer); 
     2009      } catch (e) {} 
    17492010    } 
    17502011  } 
     
    17522013 
    17532014/* prevent memory leaks in IE */ 
    1754 Event.observe(window, 'unload', Event.unloadCache, false); 
     2015if (navigator.appVersion.match(/\bMSIE\b/)) 
     2016  Event.observe(window, 'unload', Event.unloadCache, false); 
    17552017var Position = { 
    17562018  // set to true if needed, warning: firefox performance problems 
     
    18552117  }, 
    18562118 
    1857   clone: function(source, target) { 
    1858     source = $(source); 
    1859     target = $(target); 
    1860     target.style.position = 'absolute'; 
    1861     var offsets = this.cumulativeOffset(source); 
    1862     target.style.top    = offsets[1] + 'px'; 
    1863     target.style.left   = offsets[0] + 'px'; 
    1864     target.style.width  = source.offsetWidth + 'px'; 
    1865     target.style.height = source.offsetHeight + 'px'; 
    1866   }, 
    1867  
    18682119  page: function(forElement) { 
    18692120    var valueT = 0, valueL = 0; 
     
    18822133    element = forElement; 
    18832134    do { 
    1884       valueT -= element.scrollTop  || 0; 
    1885       valueL -= element.scrollLeft || 0; 
     2135      if (!window.opera || element.tagName=='BODY') { 
     2136        valueT -= element.scrollTop  || 0; 
     2137        valueL -= element.scrollLeft || 0; 
     2138      } 
    18862139    } while (element = element.parentNode); 
    18872140 
     
    19842237  } 
    19852238} 
     2239 
     2240Element.addMethods();