/* Prototype JavaScript framework, version 1.4.0                                           
 * (c) 2005 Sam Stephenson <sam@conio.net>                                                
 *                                                                                        
 * THIS FILE IS AUTOMATICALLY GENERATED. When sending patches, please diff                
 * against the source tree, available from the Prototype darcs repository.                
 *                                                                                        
 * Prototype is freely distributable under the terms of an MIT-style license.             
 *                                                                                        
 * For details, see the Prototype web site: http://prototype.conio.net/                   
 *                                                                                       
/*--------------------------------------------------------------------------*/           
                                                                                         
var Prototype = {                                                                        
 Version: '1.4.0',                                                                       
 ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',                           
                                                                                         
 emptyFunction: function() {},                                                           
 K: function(x) {return x}                                                               
}                                                                                        
                                                                                         
var Class = {                                                                            
 create: function() {                                                                    
 return function() {                                                                     
 this.initialize.apply(this, arguments);                                                 
 }                                                                                       
 }                                                                                       
}                                                                                        
                                                                                         
var Abstract = new Object();                                                             
                                                                                         
Object.extend = function(destination, source) {                                          
 for (property in source) {                                                              
 destination[property] = source[property];                                               
 }                                                                                       
 return destination;                                                                     
}                                                                                        
                                                                                         
Object.inspect = function(object) {                                                      
 try {                                                                                   
 if (object == undefined) return 'undefined';                                            
 if (object == null) return 'null';                                                      
 return object.inspect ? object.inspect() : object.toString();                           
 } catch (e) {                                                                           
 if (e instanceof RangeError) return '...';                                              
 throw e;                                                                                
 }                                                                                       
}                                                                                        
                                                                                         
Function.prototype.bind = function() {                                                   
 var __method = this, args = $A(arguments), object = args.shift();                       
 return function() {                                                                     
 return __method.apply(object, args.concat($A(arguments)));                              
 }                                                                                       
}                                                                                        
                                                                                         
Function.prototype.bindAsEventListener = function(object) {                              
 var __method = this;                                                                    
 return function(event) {                                                                
 return __method.call(object, event || window.event);                                    
 }                                                                                       
}                                                                                        
                                                                                         
Object.extend(Number.prototype, {                                                        
 toColorPart: function() {                                                               
 var digits = this.toString(16);                                                         
 if (this < 16) return '0' + digits;                                                     
 return digits;                                                                          
 },                                                                                      
                                                                                         
 succ: function() {                                                                      
 return this + 1;                                                                        
 },                                                                                      
                                                                                         
 times: function(iterator) {                                                             
 $R(0, this, true).each(iterator);                                                       
 return this;                                                                            
 }                                                                                       
});                                                                                      
                                                                                         
var Try = {                                                                              
 these: function() {                                                                     
 var returnValue;                                                                        
                                                                                         
 for (var i = 0; i < arguments.length; i++) {                                            
 var lambda = arguments[i];                                                              
 try {                                                                                   
 returnValue = lambda();                                                                 
 break;                                                                                  
 } catch (e) {}                                                                          
 }                                                                                       
                                                                                         
 return returnValue;                                                                     
 }                                                                                       
}                                                                                        
                                                                                         
/*--------------------------------------------------------------------------*/           
                                                                                         
var PeriodicalExecuter = Class.create();                                                 
PeriodicalExecuter.prototype = {                                                         
 initialize: function(callback, frequency) {                                            
 this.callback = callback;                                                              
 this.frequency = frequency;                                                            
 this.currentlyExecuting = false;                                                       
                                                                                        
 this.registerCallback();                                                               
 },                                                                                     
                                                                                        
 registerCallback: function() {                                                         
 setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);                      
 },                                                                                     
                                                                                        
 onTimerEvent: function() {                                                             
 if (!this.currentlyExecuting) {                                                        
 try {                                                                                  
 this.currentlyExecuting = true;                                                        
 this.callback();                                                                       
 } finally {                                                                            
 this.currentlyExecuting = false;                                                       
 }                                                                                      
 }                                                                                      
 }                                                                                      
}                                                                                       
                                                                                        
/*--------------------------------------------------------------------------*/          
                                                                                        
function $() {                                                                          
 var elements = new Array();                                                            
                                                                                        
 for (var i = 0; i < arguments.length; i++) {                                           
 var element = arguments[i];                                                            
 if (typeof element == 'string')                                                        
 element = document.getElementById(element);                                            
                                                                                        
 if (arguments.length == 1)                                                             
 return element;                                                                        
                                                                                        
 elements.push(element);                                                                
 }                                                                                      
                                                                                        
 return elements;                                                                       
}                                                                                       
Object.extend(String.prototype, {                                                       
 stripTags: function() {                                                                
 return this.replace(/<\/?[^>]+>/gi, '');                                               
 },                                                                                     
                                                                                        
 stripScripts: function() {                                                             
 return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');                  
 },                                                                                     
                                                                                        
 extractScripts: function() {                                                           
 var matchAll = new RegExp(Prototype.ScriptFragment, 'img');                            
 var matchOne = new RegExp(Prototype.ScriptFragment, 'im');                             
 return (this.match(matchAll) || []).map(function(scriptTag) {                          
 return (scriptTag.match(matchOne) || ['', ''])[1];                                     
 });                                                                                    
 },                                                                                     
                                                                                        
 evalScripts: function() {                                                              
 return this.extractScripts().map(eval);                                                
 },                                                                                     
                                                                                        
 escapeHTML: function() {                                                               
 var div = document.createElement('div');                                               
 var text = document.createTextNode(this);                                              
 div.appendChild(text);                                                                 
 return div.innerHTML;                                                                  
 },                                                                                     
                                                                                        
 unescapeHTML: function() {                                                             
 var div = document.createElement('div');                                               
 div.innerHTML = this.stripTags();                                                      
 return div.childNodes[0] ? div.childNodes[0].nodeValue : '';                           
 },                                                                                     
                                                                                        
 toQueryParams: function() {                                                            
 var pairs = this.match(/^\??(.*)$/)[1].split('&');                                     
 return pairs.inject({}, function(params, pairString) {                                 
 var pair = pairString.split('=');                                                      
 params[pair[0]] = pair[1];                                                             
 return params;                                                                         
 });                                                                                    
 },                                                                                     
                                                                                        
 toArray: function() {                                                                  
 return this.split('');                                                                 
 },                                                                                     
                                                                                        
 camelize: function() {                                                                 
 var oStringList = this.split('-');                                                     
 if (oStringList.length == 1) return oStringList[0];                                    
                                                                                        
 var camelizedString = this.indexOf('-') == 0                                           
 ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1)                 
 : oStringList[0];                                                                      
                                                                                        
 for (var i = 1, len = oStringList.length; i < len; i++) {                              
 var s = oStringList[i];                                                                
 camelizedString += s.charAt(0).toUpperCase() + s.substring(1);                         
 }                                                                                      
                                                                                        
 return camelizedString;                                                                
 },                                                                                     
                                                                                        
 inspect: function() {                                                                  
 return "'" + this.replace('\\', '\\\\').replace("'", '\\\'') + "'";                    
 }                                                                                      
});                                                                                     
                                                                                        
String.prototype.parseQuery = String.prototype.toQueryParams;                           
                                                                                        
var $break = new Object();                                                              
var $continue = new Object();                                                           
                                                                                        
var Enumerable = {                                                                      
 each: function(iterator) {                                                             
 var index = 0;                                                                         
 try {                                                                                  
 this._each(function(value) {                                                           
 try {                                                                                  
 iterator(value, index++);                                                              
 } catch (e) {                                                                          
 if (e != $continue) throw e;                                                           
 }                                                                                      
 });                                                                                    
 } catch (e) {                                                                          
 if (e != $break) throw e;                                                              
 }                                                                                      
 },                                                                                     
                                                                                        
 all: function(iterator) {                                                              
 var result = true;                                                                     
 this.each(function(value, index) {                                                     
 result = result && !!(iterator || Prototype.K)(value, index);                          
 if (!result) throw $break;                                                             
 });                                                                                    
 return result;                                                                         
 },                                                                                     
                                                                                        
 any: function(iterator) {                                                              
 var result = true;                                                                     
 this.each(function(value, index) {                                                     
 if (result = !!(iterator || Prototype.K)(value, index))                                
 throw $break;                                                                          
 });                                                                                    
 return result;                                                                         
 },                                                                                     
                                                                                        
 collect: function(iterator) {                                                          
 var results = [];                                                                      
 this.each(function(value, index) {                                                     
 results.push(iterator(value, index));                                                  
 });                                                                                    
 return results;                                                                        
 },                                                                                     
                                                                                        
 detect: function (iterator) {                                                          
 var result;                                                                            
 this.each(function(value, index) {                                                     
 if (iterator(value, index)) {                                                          
 result = value;                                                                        
 throw $break;                                                                          
 }                                                                                      
 });                                                                                    
 return result;                                                                         
 },                                                                                     
                                                                                        
 findAll: function(iterator) {                                                          
 var results = [];                                                                      
 this.each(function(value, index) {                                                     
 if (iterator(value, index))                                                            
 results.push(value);                                                                   
 });                                                                                    
 return results;                                                                        
 },                                                                                     
                                                                                        
 grep: function(pattern, iterator) {                                                    
 var results = [];                                                                      
 this.each(function(value, index) {                                                     
 var stringValue = value.toString();                                                    
 if (stringValue.match(pattern))                                                        
 results.push((iterator || Prototype.K)(value, index));                                 
 })                                                                                     
 return results;                                                                        
 },                                                                                     
                                                                                        
 include: function(object) {                                                            
 var found = false;                                                                     
 this.each(function(value) {                                                            
 if (value == object) {                                                                 
 found = true;                                                                          
 throw $break;                                                                          
 }                                                                                      
 });                                                                                    
 return found;                                                                          
 },                                                                                     
                                                                                        
 inject: function(memo, iterator) {                                                     
 this.each(function(value, index) {                                                     
 memo = iterator(memo, value, index);                                                   
 });                                                                                    
 return memo;                                                                           
 },                                                                                     
                                                                                        
 invoke: function(method) {                                                             
 var args = $A(arguments).slice(1);                                                     
 return this.collect(function(value) {                                                  
 return value[method].apply(value, args);                                               
 });                                                                                    
 },                                                                                     
                                                                                        
 max: function(iterator) {                                                              
 var result;                                                                            
 this.each(function(value, index) {                                                     
 value = (iterator || Prototype.K)(value, index);                                       
 if (value >= (result || value))                                                        
 result = value;                                                                        
 });                                                                                    
 return result;                                                                         
 },                                                                                     
                                                                                        
 min: function(iterator) {                                                              
 var result;                                                                            
 this.each(function(value, index) {                                                     
 value = (iterator || Prototype.K)(value, index);                                       
 if (value <= (result || value))                                                        
 result = value;                                                                        
 });                                                                                    
 return result;                                                                         
 },                                                                                     
                                                                                        
 partition: function(iterator) {                                                        
 var trues = [], falses = [];                                                           
 this.each(function(value, index) {                                                     
 ((iterator || Prototype.K)(value, index) ?                                             
 trues : falses).push(value);                                                           
 });                                                                                    
 return [trues, falses];                                                                
 },                                                                                     
                                                                                        
 pluck: function(property) {                                                            
 var results = [];                                                                      
 this.each(function(value, index) {                                                     
 results.push(value[property]);                                                         
 });                                                                                    
 return results;                                                                        
 },                                                                                     
                                                                                        
 reject: function(iterator) {                                                           
 var results = [];                                                                      
 this.each(function(value, index) {                                                     
 if (!iterator(value, index))                                                           
 results.push(value);                                                                   
 });                                                                                    
 return results;                                                                        
 },                                                                                     
                                                                                        
 sortBy: function(iterator) {                                                           
 return this.collect(function(value, index) {                                           
 return {value: value, criteria: iterator(value, index)};                               
 }).sort(function(left, right) {                                                        
 var a = left.criteria, b = right.criteria;                                             
 return a < b ? -1 : a > b ? 1 : 0;                                                     
 }).pluck('value');                                                                     
 },                                                                                     
                                                                                        
 toArray: function() {                                                                  
 return this.collect(Prototype.K);                                                      
 },                                                                                     
                                                                                        
 zip: function() {                                                                      
 var iterator = Prototype.K, args = $A(arguments);                                      
 if (typeof args.last() == 'function')                                                  
 iterator = args.pop();                                                                 
                                                                                        
 var collections = [this].concat(args).map($A);                                         
 return this.map(function(value, index) {                                               
 iterator(value = collections.pluck(index));                                            
 return value;                                                                          
 });                                                                                    
 },                                                                                     
                                                                                        
 inspect: function() {                                                                  
 return '#<Enumerable:' + this.toArray().inspect() + '>';                               
 }                                                                                      
}                                                                                       
                                                                                        
Object.extend(Enumerable, {                                                             
 map: Enumerable.collect,                                                               
 find: Enumerable.detect,                                                               
 select: Enumerable.findAll,                                                            
 member: Enumerable.include,                                                            
 entries: Enumerable.toArray                                                            
});                                                                                     
var $A = Array.from = function(iterable) {                                              
 if (!iterable) return [];                                                              
 if (iterable.toArray) {                                                                
 return iterable.toArray();                                                             
 } else {                                                                               
 var results = [];                                                                      
 for (var i = 0; i < iterable.length; i++)                                              
 results.push(iterable[i]);                                                             
 return results;                                                                        
 }                                                                                      
}                                                                                       
                                                                                        
Object.extend(Array.prototype, Enumerable);                                             
                                                                                        
Array.prototype._reverse = Array.prototype.reverse;                                     
                                                                                        
Object.extend(Array.prototype, {                                                        
 _each: function(iterator) {                                                            
 for (var i = 0; i < this.length; i++)                                                  
 iterator(this[i]);                                                                     
 },                                                                                     
                                                                                        
 clear: function() {                                                                    
 this.length = 0;                                                                       
 return this;                                                                           
 },                                                                                     
                                                                                        
 first: function() {                                                                    
 return this[0];                                                                        
 },                                                                                     
                                                                                        
 last: function() {                                                                     
 return this[this.length - 1];                                                          
 },                                                                                     
                                                                                        
 compact: function() {                                                                  
 return this.select(function(value) {                                                   
 return value != undefined || value != null;                                            
 });                                                                                    
 },                                                                                     
                                                                                        
 flatten: function() {                                                                  
 return this.inject([], function(array, value) {                                        
 return array.concat(value.constructor == Array ?                                       
 value.flatten() : [value]);                                                            
 });                                                                                    
 },                                                                                     
                                                                                        
 without: function() {                                                                  
 var values = $A(arguments);                                                            
 return this.select(function(value) {                                                   
 return !values.include(value);                                                         
 });                                                                                    
 },                                                                                     
                                                                                        
 indexOf: function(object) {                                                            
 for (var i = 0; i < this.length; i++)                                                  
 if (this[i] == object) return i;                                                       
 return -1;                                                                             
 },                                                                                     
                                                                                        
 reverse: function(inline) {                                                            
 return (inline !== false ? this : this.toArray())._reverse();                          
 },                                                                                     
                                                                                        
 shift: function() {                                                                    
 var result = this[0];                                                                  
 for (var i = 0; i < this.length - 1; i++)                                              
 this[i] = this[i + 1];                                                                 
 this.length--;                                                                         
 return result;                                                                         
 },                                                                                     
                                                                                        
 inspect: function() {                                                                  
 return '[' + this.map(Object.inspect).join(', ') + ']';                                
 }                                                                                      
});                                                                                     
var Hash = {                                                                            
 _each: function(iterator) {                                                            
 for (key in this) {                                                                    
 var value = this[key];                                                                 
 if (typeof value == 'function') continue;                                              
                                                                                        
 var pair = [key, value];                                                               
 pair.key = key;                                                                        
 pair.value = value;                                                                    
 iterator(pair);                                                                        
 }                                                                                      
 },                                                                                     
                                                                                        
 keys: function() {                                                                     
 return this.pluck('key');                                                              
 },                                                                                     
                                                                                        
 values: function() {                                                                   
 return this.pluck('value');                                                            
 },                                                                                     
                                                                                        
 merge: function(hash) {                                                                
 return $H(hash).inject($H(this), function(mergedHash, pair) {                          
 mergedHash[pair.key] = pair.value;                                                     
 return mergedHash;                                                                     
 });                                                                                    
 },                                                                                     
                                                                                        
 toQueryString: function() {                                                            
 return this.map(function(pair) {                                                       
 return pair.map(encodeURIComponent).join('=');                                         
 }).join('&');                                                                          
 },                                                                                     
                                                                                        
 inspect: function() {                                                                  
 return '#<Hash:{' + this.map(function(pair) {                                          
 return pair.map(Object.inspect).join(': ');                                            
 }).join(', ') + '}>';                                                                  
 }                                                                                      
}                                                                                       
                                                                                        
function $H(object) {                                                                   
 var hash = Object.extend({}, object || {});                                            
 Object.extend(hash, Enumerable);                                                       
 Object.extend(hash, Hash);                                                             
 return hash;                                                                           
}                                                                                       
ObjectRange = Class.create();                                                           
Object.extend(ObjectRange.prototype, Enumerable);                                       
Object.extend(ObjectRange.prototype, {                                                  
 initialize: function(start, end, exclusive) {                                          
 this.start = start;                                                                    
 this.end = end;                                                                        
 this.exclusive = exclusive;                                                            
 },                                                                                     
                                                                                        
 _each: function(iterator) {                                                            
 var value = this.start;                                                                
 do {                                                                                   
 iterator(value);                                                                       
 value = value.succ();                                                                  
 } while (this.include(value));                                                         
 },                                                                                     
                                                                                        
 include: function(value) {                                                             
 if (value < this.start)                                                                
 return false;                                                                          
 if (this.exclusive)                                                                    
 return value < this.end;                                                               
 return value <= this.end;                                                              
 }                                                                                      
});                                                                                     
                                                                                        
var $R = function(start, end, exclusive) {                                              
 return new ObjectRange(start, end, exclusive);                                         
}                                                                                       
                                                                                        
var Ajax = {                                                                            
 getTransport: function() {                                                             
 return Try.these(                                                                      
 function() {return new ActiveXObject('Msxml2.XMLHTTP')},                               
 function() {return new ActiveXObject('Microsoft.XMLHTTP')},                            
 function() {return new XMLHttpRequest()}                                               
 ) || false;                                                                            
 },                                                                                     
                                                                                        
 activeRequestCount: 0                                                                  
}                                                                                       
                                                                                        
Ajax.Responders = {                                                                     
 responders: [],                                                                        
                                                                                        
 _each: function(iterator) {                                                            
 this.responders._each(iterator);                                                       
 },                                                                                     
                                                                                        
 register: function(responderToAdd) {                                                   
 if (!this.include(responderToAdd))                                                     
 this.responders.push(responderToAdd);                                                  
 },                                                                                     
                                                                                        
 unregister: function(responderToRemove) {                                              
 this.responders = this.responders.without(responderToRemove);                          
 },                                                                                     
                                                                                        
 dispatch: function(callback, request, transport, json) {                               
 this.each(function(responder) {                                                        
 if (responder[callback] && typeof responder[callback] == 'function') {                 
 try {                                                                                  
 responder[callback].apply(responder, [request, transport, json]);                      
 } catch (e) {}                                                                         
 }                                                                                      
 });                                                                                    
 }                                                                                      
};                                                                                      
                                                                                        
Object.extend(Ajax.Responders, Enumerable);                                             
                                                                                        
Ajax.Responders.register({                                                              
 onCreate: function() {                                                                 
 Ajax.activeRequestCount++;                                                             
 },                                                                                     
                                                                                        
 onComplete: function() {                                                               
 Ajax.activeRequestCount--;                                                             
 }                                                                                      
});                                                                                     
                                                                                        
Ajax.Base = function() {};                                                              
Ajax.Base.prototype = {                                                                 
 setOptions: function(options) {                                                        
 this.options = {                                                                       
 method: 'post',                                                                        
 asynchronous: true,                                                                    
 parameters: ''                                                                         
 }                                                                                      
 Object.extend(this.options, options || {});                                            
 },                                                                                     
                                                                                        
 responseIsSuccess: function() {                                                        
 return this.transport.status == undefined                                              
 || this.transport.status == 0                                                          
 || (this.transport.status >= 200 && this.transport.status < 300);                      
 },                                                                                     
                                                                                        
 responseIsFailure: function() {                                                        
 return !this.responseIsSuccess();                                                      
 }                                                                                      
}                                                                                       
                                                                                        
Ajax.Request = Class.create();                                                          
Ajax.Request.Events =                                                                   
 ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];                     
                                                                                        
Ajax.Request.prototype = Object.extend(new Ajax.Base(), {                               
 initialize: function(url, options) {                                                   
 this.transport = Ajax.getTransport();                                                  
 this.setOptions(options);                                                              
 this.request(url);                                                                     
 },                                                                                     
                                                                                        
 request: function(url) {                                                               
 var parameters = this.options.parameters || '';                                        
 if (parameters.length > 0) parameters += '&_=';                                        
                                                                                        
 try {                                                                                  
 this.url = url;                                                                        
 if (this.options.method == 'get' && parameters.length > 0)                             
 this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;                           
                                                                                        
 Ajax.Responders.dispatch('onCreate', this, this.transport);                            
                                                                                        
 this.transport.open(this.options.method, this.url,                                     
 this.options.asynchronous);                                                            
                                                                                        
 if (this.options.asynchronous) {                                                       
 this.transport.onreadystatechange = this.onStateChange.bind(this);                     
 setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10);                 
 }                                                                                      
                                                                                        
 this.setRequestHeaders();                                                              
                                                                                        
 var body = this.options.postBody ? this.options.postBody : parameters;                 
 this.transport.send(this.options.method == 'post' ? body : null);                      
                                                                                        
 } catch (e) {                                                                          
 this.dispatchException(e);                                                             
 }                                                                                      
 },                                                                                     
                                                                                        
 setRequestHeaders: function() {                                                        
 var requestHeaders =                                                                   
 ['X-Requested-With', 'XMLHttpRequest',                                                 
 'X-Prototype-Version', Prototype.Version];                                             
                                                                                        
 if (this.options.method == 'post') {                                                   
 requestHeaders.push('Content-type',                                                    
 'application/x-www-form-urlencoded');                                                  
                                                                                        
 /* Force "Connection: close" for Mozilla browsers to work around                       
 * a bug where XMLHttpReqeuest sends an incorrect Content-length                        
 * header. See Mozilla Bugzilla #246651.                                                
 */                                                                                     
 if (this.transport.overrideMimeType)                                                   
 requestHeaders.push('Connection', 'close');                                            
 }                                                                                      
                                                                                        
 if (this.options.requestHeaders)                                                       
 requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);                
                                                                                        
 for (var i = 0; i < requestHeaders.length; i += 2)                                     
 this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);               
 },                                                                                     
                                                                                        
 onStateChange: function() {                                                            
 var readyState = this.transport.readyState;                                            
 if (readyState != 1)                                                                   
 this.respondToReadyState(this.transport.readyState);                                   
 },                                                                                     
                                                                                        
 header: function(name) {                                                               
 try {                                                                                  
 return this.transport.getResponseHeader(name);                                         
 } catch (e) {}                                                                         
 },                                                                                     
                                                                                        
 evalJSON: function() {                                                                 
 try {                                                                                  
 return eval(this.header('X-JSON'));                                                    
 } catch (e) {}                                                                         
 },                                                                                     
                                                                                        
 evalResponse: function() {                                                             
 try {                                                                                  
 return eval(this.transport.responseText);                                              
 } catch (e) {                                                                          
 this.dispatchException(e);                                                             
 }                                                                                      
 },                                                                                     
                                                                                        
 respondToReadyState: function(readyState) {                                            
 var event = Ajax.Request.Events[readyState];                                           
 var transport = this.transport, json = this.evalJSON();                                
                                                                                        
 if (event == 'Complete') {                                                             
 try {                                                                                  
 (this.options['on' + this.transport.status]                                            
 || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]             
 || Prototype.emptyFunction)(transport, json);                                          
 } catch (e) {                                                                          
 this.dispatchException(e);                                                             
 }                                                                                      
                                                                                        
 if ((this.header('Content-type') || '').match(/^text\/javascript/i))                   
 this.evalResponse();                                                                   
 }                                                                                      
                                                                                        
 try {                                                                                  
 (this.options['on' + event] || Prototype.emptyFunction)(transport, json);              
 Ajax.Responders.dispatch('on' + event, this, transport, json);                         
 } catch (e) {                                                                          
 this.dispatchException(e);                                                             
 }                                                                                      
                                                                                        
 /* Avoid memory leak in MSIE: clean up the oncomplete event handler */                 
 if (event == 'Complete')                                                               
 this.transport.onreadystatechange = Prototype.emptyFunction;                           
 },                                                                                     
                                                                                        
 dispatchException: function(exception) {                                               
 (this.options.onException || Prototype.emptyFunction)(this, exception);                
 Ajax.Responders.dispatch('onException', this, exception);                              
 }                                                                                      
});                                                                                     
                                                                                        
Ajax.Updater = Class.create();                                                          
                                                                                        
Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {          
 initialize: function(container, url, options) {                                        
 this.containers = {                                                                    
 success: container.success ? $(container.success) : $(container),                      
 failure: container.failure ? $(container.failure) :                                    
 (container.success ? null : $(container))                                              
 }                                                                                      
                                                                                        
 this.transport = Ajax.getTransport();                                                  
 this.setOptions(options);                                                              
                                                                                        
 var onComplete = this.options.onComplete || Prototype.emptyFunction;                   
 this.options.onComplete = (function(transport, object) {                               
 this.updateContent();                                                                  
 onComplete(transport, object);                                                         
 }).bind(this);                                                                         
                                                                                        
 this.request(url);                                                                     
 },                                                                                     
                                                                                        
 updateContent: function() {                                                            
 var receiver = this.responseIsSuccess() ?                                              
 this.containers.success : this.containers.failure;                                     
 var response = this.transport.responseText;                                            
                                                                                        
 if (!this.options.evalScripts)                                                         
 response = response.stripScripts();                                                    
                                                                                        
 if (receiver) {                                                                        
 if (this.options.insertion) {                                                          
 new this.options.insertion(receiver, response);                                        
 } else {                                                                               
 Element.update(receiver, response);                                                    
 }                                                                                      
 }                                                                                      
                                                                                        
 if (this.responseIsSuccess()) {                                                        
 if (this.onComplete)                                                                   
 setTimeout(this.onComplete.bind(this), 10);                                            
 }                                                                                      
 }                                                                                      
});                                                                                     
                                                                                        
Ajax.PeriodicalUpdater = Class.create();                                                
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {                     
 initialize: function(container, url, options) {                                        
 this.setOptions(options);                                                              
 this.onComplete = this.options.onComplete;                                             
                                                                                        
 this.frequency = (this.options.frequency || 2);                                        
 this.decay = (this.options.decay || 1);                                                
                                                                                        
 this.updater = {};                                                                     
 this.container = container;                                                            
 this.url = url;                                                                        
                                                                                        
 this.start();                                                                          
 },                                                                                     
                                                                                        
 start: function() {                                                                    
 this.options.onComplete = this.updateComplete.bind(this);                              
 this.onTimerEvent();                                                                   
 },                                                                                     
                                                                                        
 stop: function() {                                                                     
 this.updater.onComplete = undefined;                                                   
 clearTimeout(this.timer);                                                              
 (this.onComplete || Prototype.emptyFunction).apply(this, arguments);                   
 },                                                                                     
                                                                                        
 updateComplete: function(request) {                                                    
 if (this.options.decay) {                                                              
 this.decay = (request.responseText == this.lastText ?                                  
 this.decay * this.options.decay : 1);                                                  
                                                                                        
 this.lastText = request.responseText;                                                  
 }                                                                                      
 this.timer = setTimeout(this.onTimerEvent.bind(this),                                  
 this.decay * this.frequency * 1000);                                                   
 },                                                                                     
                                                                                        
 onTimerEvent: function() {                                                             
 this.updater = new Ajax.Updater(this.container, this.url, this.options);               
 }                                                                                      
});                                                                                     
document.getElementsByClassName = function(className, parentElement) {                  
 var children = ($(parentElement) || document.body).getElementsByTagName('*');          
 return $A(children).inject([], function(elements, child) {                             
 if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))              
 elements.push(child);                                                                  
 return elements;                                                                       
 });                                                                                    
}                                                                                       
                                                                                        
/*--------------------------------------------------------------------------*/          
                                                                                        
if (!window.Element) {                                                                  
 var Element = new Object();                                                            
}                                                                                       
                                                                                        
Object.extend(Element, {                                                                
 visible: function(element) {                                                           
 return $(element).style.display != 'none';                                             
 },                                                                                     
                                                                                        
 toggle: function() {                                                                   
 for (var i = 0; i < arguments.length; i++) {                                           
 var element = $(arguments[i]);                                                         
 Element[Element.visible(element) ? 'hide' : 'show'](element);                          
 }                                                                                      
 },                                                                                     
                                                                                        
 hide: function() {                                                                     
 for (var i = 0; i < arguments.length; i++) {                                           
 var element = $(arguments[i]);                                                         
 element.style.display = 'none';                                                        
 }                                                                                      
 },                                                                                     
                                                                                        
 show: function() {                                                                     
 for (var i = 0; i < arguments.length; i++) {                                           
 var element = $(arguments[i]);                                                         
 element.style.display = '';                                                            
 }                                                                                      
 },                                                                                     
                                                                                        
 remove: function(element) {                                                            
 element = $(element);                                                                  
 element.parentNode.removeChild(element);                                               
 },                                                                                     
                                                                                        
 update: function(element, html) {                                                      
 $(element).innerHTML = html.stripScripts();                                            
 setTimeout(function() {html.evalScripts()}, 10);                                       
 },                                                                                     
                                                                                        
 getHeight: function(element) {                                                         
 element = $(element);                                                                  
 return element.offsetHeight;                                                           
 },                                                                                     
                                                                                        
 classNames: function(element) {                                                        
 return new Element.ClassNames(element);                                                
 },                                                                                     
                                                                                        
 hasClassName: function(element, className) {                                           
 if (!(element = $(element))) return;                                                   
 return Element.classNames(element).include(className);                                 
 },                                                                                     
                                                                                        
 addClassName: function(element, className) {                                           
 if (!(element = $(element))) return;                                                   
 return Element.classNames(element).add(className);                                     
 },                                                                                     
                                                                                        
 removeClassName: function(element, className) {                                        
 if (!(element = $(element))) return;                                                   
 return Element.classNames(element).remove(className);                                  
 },                                                                                     
                                                                                        
 // removes whitespace-only text node children                                          
 cleanWhitespace: function(element) {                                                   
 element = $(element);                                                                  
 for (var i = 0; i < element.childNodes.length; i++) {                                  
 var node = element.childNodes[i];                                                      
 if (node.nodeType == 3 && !/\S/.test(node.nodeValue))                                  
 Element.remove(node);                                                                  
 }                                                                                      
 },                                                                                     
                                                                                        
 empty: function(element) {                                                             
 return $(element).innerHTML.match(/^\s*$/);                                            
 },                                                                                     
                                                                                        
 scrollTo: function(element) {                                                          
 element = $(element);                                                                  
 var x = element.x ? element.x : element.offsetLeft,                                    
 y = element.y ? element.y : element.offsetTop;                                         
 window.scrollTo(x, y);                                                                 
 },                                                                                     
                                                                                        
 getStyle: function(element, style) {                                                   
 element = $(element);                                                                  
 var value = element.style[style.camelize()];                                           
 if (!value) {                                                                          
 if (document.defaultView && document.defaultView.getComputedStyle) {                   
 var css = document.defaultView.getComputedStyle(element, null);                        
 value = css ? css.getPropertyValue(style) : null;                                      
 } else if (element.currentStyle) {                                                     
 value = element.currentStyle[style.camelize()];                                        
 }                                                                                      
 }                                                                                      
                                                                                        
 if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))                 
 if (Element.getStyle(element, 'position') == 'static') value = 'auto';                 
                                                                                        
 return value == 'auto' ? null : value;                                                 
 },                                                                                     
                                                                                        
 setStyle: function(element, style) {                                                   
 element = $(element);                                                                  
 for (name in style)                                                                    
 element.style[name.camelize()] = style[name];                                          
 },                                                                                     
                                                                                        
 getDimensions: function(element) {                                                     
 element = $(element);                                                                  
 if (Element.getStyle(element, 'display') != 'none')                                    
 return {width: element.offsetWidth, height: element.offsetHeight};                     
                                                                                        
 // All *Width and *Height properties give 0 on elements with display none,             
 // so enable the element temporarily                                                   
 var els = element.style;                                                               
 var originalVisibility = els.visibility;                                               
 var originalPosition = els.position;                                                   
 els.visibility = 'hidden';                                                             
 els.position = 'absolute';                                                             
 els.display = '';                                                                      
 var originalWidth = element.clientWidth;                                               
 var originalHeight = element.clientHeight;                                             
 els.display = 'none';                                                                  
 els.position = originalPosition;                                                       
 els.visibility = originalVisibility;                                                   
 return {width: originalWidth, height: originalHeight};                                 
 },                                                                                     
                                                                                        
 makePositioned: function(element) {                                                    
 element = $(element);                                                                  
 var pos = Element.getStyle(element, 'position');                                       
 if (pos == 'static' || !pos) {                                                         
 element._madePositioned = true;                                                        
 element.style.position = 'relative';                                                   
 // Opera returns the offset relative to the positioning context, when an               
 // element is position relative but top and left have not been defined                 
 if (window.opera) {                                                                    
 element.style.top = 0;                                                                 
 element.style.left = 0;                                                                
 }                                                                                      
 }                                                                                      
 },                                                                                     
                                                                                        
 undoPositioned: function(element) {                                                    
 element = $(element);                                                                  
 if (element._madePositioned) {                                                         
 element._madePositioned = undefined;                                                   
 element.style.position =                                                               
 element.style.top =                                                                    
 element.style.left =                                                                   
 element.style.bottom =                                                                 
 element.style.right = '';                                                              
 }                                                                                      
 },                                                                                    
                                                                                       
 makeClipping: function(element) {                                                     
 element = $(element);                                                                 
 if (element._overflow) return;                                                        
 element._overflow = element.style.overflow;                                           
 if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')                 
 element.style.overflow = 'hidden';                                                    
 },                                                                                    
                                                                                       
 undoClipping: function(element) {                                                     
 element = $(element);                                                                 
 if (element._overflow) return;                                                        
 element.style.overflow = element._overflow;                                           
 element._overflow = undefined;                                                        
 }                                                                                     
});                                                                                    
                                                                                       
var Toggle = new Object();                                                             
Toggle.display = Element.toggle;                                                       
                                                                                       
/*--------------------------------------------------------------------------*/         
                                                                                       
Abstract.Insertion = function(adjacency) {                                             
 this.adjacency = adjacency;                                                           
}                                                                                      
                                                                                       
Abstract.Insertion.prototype = {                                                       
 initialize: function(element, content) {                                              
 this.element = $(element);                                                            
 this.content = content.stripScripts();                                                
                                                                                       
 if (this.adjacency && this.element.insertAdjacentHTML) {                              
 try {                                                                                 
 this.element.insertAdjacentHTML(this.adjacency, this.content);                        
 } catch (e) {                                                                         
 if (this.element.tagName.toLowerCase() == 'tbody') {                                  
 this.insertContent(this.contentFromAnonymousTable());                                 
 } else {                                                                              
 throw e;                                                                              
 }                                                                                     
 }                                                                                     
 } else {                                                                              
 this.range = this.element.ownerDocument.createRange();                                
 if (this.initializeRange) this.initializeRange();                                     
 this.insertContent([this.range.createContextualFragment(this.content)]);              
 }                                                                                     
                                                                                       
 setTimeout(function() {content.evalScripts()}, 10);                                   
 },                                                                                    
                                                                                       
 contentFromAnonymousTable: function() {                                               
 var div = document.createElement('div');                                              
 div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';                 
 return $A(div.childNodes[0].childNodes[0].childNodes);                                
 }                                                                                     
}                                                                                      
                                                                                       
var Insertion = new Object();                                                          
                                                                                       
Insertion.Before = Class.create();                                                     
Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {    
 initializeRange: function() {                                                         
 this.range.setStartBefore(this.element);                                              
 },                                                                                    
                                                                                       
 insertContent: function(fragments) {                                                  
 fragments.each((function(fragment) {                                                  
 this.element.parentNode.insertBefore(fragment, this.element);                         
 }).bind(this));                                                                       
 }                                                                                     
});                                                                                    
                                                                                       
Insertion.Top = Class.create();                                                        
Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {        
 initializeRange: function() {                                                         
 this.range.selectNodeContents(this.element);                                          
 this.range.collapse(true);                                                            
 },                                                                                    
                                                                                       
 insertContent: function(fragments) {                                                  
 fragments.reverse(false).each((function(fragment) {                                   
 this.element.insertBefore(fragment, this.element.firstChild);                         
 }).bind(this));                                                                       
 }                                                                                     
});                                                                                    
                                                                                       
Insertion.Bottom = Class.create();                                                     
Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {      
 initializeRange: function() {                                                         
 this.range.selectNodeContents(this.element);                                          
 this.range.collapse(this.element);                                                    
 },                                                                                    
                                                                                       
 insertContent: function(fragments) {                                                  
 fragments.each((function(fragment) {                                                  
 this.element.appendChild(fragment);                                                   
 }).bind(this));                                                                       
 }                                                                                     
});                                                                                    
                                                                                       
Insertion.After = Class.create();                                                      
Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {        
 initializeRange: function() {                                                         
 this.range.setStartAfter(this.element);                                               
 },                                                                                    
                                                                                       
 insertContent: function(fragments) {                                                  
 fragments.each((function(fragment) {                                                  
 this.element.parentNode.insertBefore(fragment,                                        
 this.element.nextSibling);                                                            
 }).bind(this));                                                                       
 }                                                                                     
});                                                                                    
                                                                                       
/*--------------------------------------------------------------------------*/         
                                                                                       
Element.ClassNames = Class.create();                                                   
Element.ClassNames.prototype = {                                                       
 initialize: function(element) {                                                       
 this.element = $(element);                                                            
 },                                                                                    
                                                                                       
 _each: function(iterator) {                                                           
 this.element.className.split(/\s+/).select(function(name) {                           
 return name.length > 0;                                                               
 })._each(iterator);                                                                   
 },                                                                                    
                                                                                       
 set: function(className) {                                                            
 this.element.className = className;                                                   
 },                                                                                    
                                                                                       
 add: function(classNameToAdd) {                                                       
 if (this.include(classNameToAdd)) return;                                             
 this.set(this.toArray().concat(classNameToAdd).join(' '));                            
 },                                                                                    
                                                                                       
 remove: function(classNameToRemove) {                                                 
 if (!this.include(classNameToRemove)) return;                                         
 this.set(this.select(function(className) {                                            
 return className != classNameToRemove;                                                
 }).join(' '));                                                                        
 },                                                                                    
                                                                                       
 toString: function() {                                                                
 return this.toArray().join(' ');                                                      
 }                                                                                     
}                                                                                      
                                                                                       
Object.extend(Element.ClassNames.prototype, Enumerable);                               
var Field = {                                                                          
 clear: function() {                                                                   
 for (var i = 0; i < arguments.length; i++)                                            
 $(arguments[i]).value = '';                                                           
 },                                                                                    
                                                                                       
 focus: function(element) {                                                            
 $(element).focus();                                                                   
 },                                                                                    
                                                                                       
 present: function() {                                                                 
 for (var i = 0; i < arguments.length; i++)                                            
 if ($(arguments[i]).value == '') return false;                                        
 return true;                                                                          
 },                                                                                    
                                                                                       
 select: function(element) {                                                           
 $(element).select();                                                                  
 },                                                                                    
                                                                                       
 activate: function(element) {                                                         
 element = $(element);                                                                 
 element.focus();                                                                      
 if (element.select)                                                                   
 element.select();                                                                     
 }                                                                                     
}                                                                                      
                                                                                       
/*--------------------------------------------------------------------------*/         
                                                                                       
var Form = {                                                                           
 serialize: function(form) {                                                           
 var elements = Form.getElements($(form));                                             
 var queryComponents = new Array();                                                    
                                                                                       
 for (var i = 0; i < elements.length; i++) {                                           
 var queryComponent = Form.Element.serialize(elements[i]);                             
 if (queryComponent)                                                                   
 queryComponents.push(queryComponent);                                                 
 }                                                                                     
                                                                                       
 return queryComponents.join('&');                                                     
 },                                                                                    
                                                                                       
 getElements: function(form) {                                                         
 form = $(form);                                                                       
 var elements = new Array();                                                           
                                                                                       
 for (tagName in Form.Element.Serializers) {                                           
 var tagElements = form.getElementsByTagName(tagName);                                 
 for (var j = 0; j < tagElements.length; j++)                                          
 elements.push(tagElements[j]);                                                        
 }                                                                                     
 return elements;                                                                      
 },                                                                                    
                                                                                       
 getInputs: function(form, typeName, name) {                                           
 form = $(form);                                                                       
 var inputs = form.getElementsByTagName('input');                                      
                                                                                       
 if (!typeName && !name)                                                               
 return inputs;                                                                        
                                                                                       
 var matchingInputs = new Array();                                                     
 for (var i = 0; i < inputs.length; i++) {                                             
 var input = inputs[i];                                                                
 if ((typeName && input.type != typeName) ||                                           
 (name && input.name != name))                                                         
 continue;                                                                             
 matchingInputs.push(input);                                                           
 }                                                                                     
                                                                                       
 return matchingInputs;                                                                
 },                                                                                    
                                                                                       
 disable: function(form) {                                                             
 var elements = Form.getElements(form);                                                
 for (var i = 0; i < elements.length; i++) {                                           
 var element = elements[i];                                                            
 element.blur();                                                                       
 element.disabled = 'true';                                                            
 }                                                                                     
 },                                                                                    
                                                                                       
 enable: function(form) {                                                              
 var elements = Form.getElements(form);                                                
 for (var i = 0; i < elements.length; i++) {                                           
 var element = elements[i];                                                            
 element.disabled = '';                                                                
 }                                                                                     
 },                                                                                    
                                                                                       
 findFirstElement: function(form) {                                                    
 return Form.getElements(form).find(function(element) {                                
 return element.type != 'hidden' && !element.disabled &&                               
 ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());               
 });                                                                                   
 },                                                                                    
                                                                                       
 focusFirstElement: function(form) {                                                   
 Field.activate(Form.findFirstElement(form));                                          
 },                                                                                    
                                                                                       
 reset: function(form) {                                                               
 $(form).reset();                                                                      
 }                                                                                     
}                                                                                      
                                                                                       
Form.Element = {                                                                       
 serialize: function(element) {                                                        
 element = $(element);                                                                 
 var method = element.tagName.toLowerCase();                                           
 var parameter = Form.Element.Serializers[method](element);                            
                                                                                       
 if (parameter) {                                                                      
 var key = encodeURIComponent(parameter[0]);                                           
 if (key.length == 0) return;                                                          
                                                                                       
 if (parameter[1].constructor != Array)                                                
 parameter[1] = [parameter[1]];                                                        
                                                                                       
 return parameter[1].map(function(value) {                                             
 return key + '=' + encodeURIComponent(value);                                         
 }).join('&');                                                                         
 }                                                                                     
 },                                                                                    
                                                                                       
 getValue: function(element) {                                                         
 element = $(element);                                                                 
 var method = element.tagName.toLowerCase();                                           
 var parameter = Form.Element.Serializers[method](element);                            
                                                                                       
 if (parameter)                                                                        
 return parameter[1];                                                                  
 }                                                                                     
}                                                                                      
                                                                                       
Form.Element.Serializers = {                                                           
 input: function(element) {                                                            
 switch (element.type.toLowerCase()) {                                                 
 case 'submit':                                                                        
 case 'hidden':                                                                        
 case 'password':                                                                      
 case 'text':                                                                          
 return Form.Element.Serializers.textarea(element);                                    
 case 'checkbox':                                                                      
 case 'radio':                                                                         
 return Form.Element.Serializers.inputSelector(element);                               
 }                                                                                     
 return false;                                                                         
 },                                                                                    
                                                                                       
 inputSelector: function(element) {                                                    
 if (element.checked)                                                                  
 return [element.name, element.value];                                                 
 },                                                                                    
                                                                                       
 textarea: function(element) {                                                         
 return [element.name, element.value];                                                 
 },                                                                                    
                                                                                       
 select: function(element) {                                                           
 return Form.Element.Serializers[element.type == 'select-one' ?                        
 'selectOne' : 'selectMany'](element);                                                 
 },                                                                                    
                                                                                       
 selectOne: function(element) {                                                        
 var value = '', opt, index = element.selectedIndex;                                   
 if (index >= 0) {                                                                     
 opt = element.options[index];                                                         
 value = opt.value;                                                                    
 if (!value && !('value' in opt))                                                      
 value = opt.text;                                                                     
 }                                                                                     
 return [element.name, value];                                                         
 },                                                                                    
                                                                                       
 selectMany: function(element) {                                                       
 var value = new Array();                                                              
 for (var i = 0; i < element.length; i++) {                                            
 var opt = element.options[i];                                                         
 if (opt.selected) {                                                                   
 var optValue = opt.value;                                                             
 if (!optValue && !('value' in opt))                                                   
 optValue = opt.text;                                                                  
 value.push(optValue);                                                                 
 }                                                                                     
 }                                                                                     
 return [element.name, value];                                                         
 }                                                                                     
}                                                                                      
                                                                                       
/*--------------------------------------------------------------------------*/         
                                                                                       
var $F = Form.Element.getValue;                                                        
                                                                                       
/*--------------------------------------------------------------------------*/         
                                                                                       
Abstract.TimedObserver = function() {}                                                 
Abstract.TimedObserver.prototype = {                                                   
 initialize: function(element, frequency, callback) {                                  
 this.frequency = frequency;                                                           
 this.element = $(element);                                                            
 this.callback = callback;                                                             
                                                                                       
 this.lastValue = this.getValue();                                                     
 this.registerCallback();                                                              
 },                                                                                    
                                                                                       
 registerCallback: function() {                                                        
 setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);                     
 },                                                                                    
                                                                                       
 onTimerEvent: function() {                                                            
 var value = this.getValue();                                                          
 if (this.lastValue != value) {                                                        
 this.callback(this.element, value);                                                   
 this.lastValue = value;                                                               
 }                                                                                     
 }                                                                                     
}                                                                                      
                                                                                       
Form.Element.Observer = Class.create();                                                
Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {        
 getValue: function() {                                                                
 return Form.Element.getValue(this.element);                                           
 }                                                                                     
});                                                                                    
                                                                                       
Form.Observer = Class.create();                                                        
Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {                
 getValue: function() {                                                                
 return Form.serialize(this.element);                                                  
 }                                                                                     
});                                                                                    
                                                                                       
/*--------------------------------------------------------------------------*/         
                                                                                       
Abstract.EventObserver = function() {}                                                 
Abstract.EventObserver.prototype = {                                                   
 initialize: function(element, callback) {                                             
 this.element = $(element);                                                            
 this.callback = callback;                                                             
                                                                                       
 this.lastValue = this.getValue();                                                     
 if (this.element.tagName.toLowerCase() == 'form')                                     
 this.registerFormCallbacks();                                                         
 else                                                                                  
 this.registerCallback(this.element);                                                  
 },                                                                                    
                                                                                       
 onElementEvent: function() {                                                          
 var value = this.getValue();                                                          
 if (this.lastValue != value) {                                                        
 this.callback(this.element, value);                                                   
 this.lastValue = value;                                                               
 }                                                                                     
 },                                                                                    
                                                                                       
 registerFormCallbacks: function() {                                                   
 var elements = Form.getElements(this.element);                                        
 for (var i = 0; i < elements.length; i++)                                             
 this.registerCallback(elements[i]);                                                   
 },                                                                                    
                                                                                       
 registerCallback: function(element) {                                                 
 if (element.type) {                                                                   
 switch (element.type.toLowerCase()) {                                                 
 case 'checkbox':                                                                      
 case 'radio':                                                                         
 Event.observe(element, 'click', this.onElementEvent.bind(this));                      
 break;                                                                                
 case 'password':                                                                      
 case 'text':                                                                          
 case 'textarea':                                                                      
 case 'select-one':                                                                    
 case 'select-multiple':                                                               
 Event.observe(element, 'change', this.onElementEvent.bind(this));                     
 break;                                                                                
 }                                                                                     
 }                                                                                     
 }                                                                                     
}                                                                                      
                                                                                       
Form.Element.EventObserver = Class.create();                                           
Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {   
 getValue: function() {                                                                
 return Form.Element.getValue(this.element);                                           
 }                                                                                     
});                                                                                    
                                                                                       
Form.EventObserver = Class.create();                                                   
Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {           
 getValue: function() {                                                                
 return Form.serialize(this.element);                                                  
 }                                                                                     
});                                                                                    
if (!window.Event) {                                                                   
 var Event = new Object();                                                             
}                                                                                      
                                                                                       
Object.extend(Event, {                                                                 
 KEY_BACKSPACE: 8,                                                                     
 KEY_TAB: 9,                                                                           
 KEY_RETURN: 13,                                                                       
 KEY_ESC: 27,                                                                          
 KEY_LEFT: 37,                                                                         
 KEY_UP: 38,                                                                           
 KEY_RIGHT: 39,                                                                        
 KEY_DOWN: 40,                                                                         
 KEY_DELETE: 46,                                                                       
                                                                                       
 element: function(event) {                                                            
 return event.target || event.srcElement;                                              
 },                                                                                    
                                                                                       
 isLeftClick: function(event) {                                                        
 return (((event.which) && (event.which == 1)) ||                                      
 ((event.button) && (event.button == 1)));                                             
 },                                                                                    
                                                                                       
 pointerX: function(event) {                                                           
 return event.pageX || (event.clientX +                                                
 (document.documentElement.scrollLeft || document.body.scrollLeft));                   
 },                                                                                    
                                                                                       
 pointerY: function(event) {                                                           
 return event.pageY || (event.clientY +                                                
 (document.documentElement.scrollTop || document.body.scrollTop));                     
 },                                                                                    
                                                                                       
 stop: function(event) {                                                               
 if (event.preventDefault) {                                                           
 event.preventDefault();                                                               
 event.stopPropagation();                                                              
 } else {                                                                              
 event.returnValue = false;                                                            
 event.cancelBubble = true;                                                            
 }                                                                                     
 },                                                                                    
                                                                                       
 // find the first node with the given tagName, starting from the                      
 // node the event was triggered on; traverses the DOM upwards                         
 findElement: function(event, tagName) {                                               
 var element = Event.element(event);                                                   
 while (element.parentNode && (!element.tagName ||                                     
 (element.tagName.toUpperCase() != tagName.toUpperCase())))                            
 element = element.parentNode;                                                         
 return element;                                                                       
 },                                                                                    
                                                                                       
 observers: false,                                                                     
                                                                                       
 _observeAndCache: function(element, name, observer, useCapture) {                     
 if (!this.observers) this.observers = [];                                             
 if (element.addEventListener) {                                                       
 this.observers.push([element, name, observer, useCapture]);                           
 element.addEventListener(name, observer, useCapture);                                 
 } else if (element.attachEvent) {                                                     
 this.observers.push([element, name, observer, useCapture]);                           
 element.attachEvent('on' + name, observer);                                           
 }                                                                                     
 },                                                                                    
                                                                                       
 unloadCache: function() {                                                             
 if (!Event.observers) return;                                                         
 for (var i = 0; i < Event.observers.length; i++) {                                    
 Event.stopObserving.apply(this, Event.observers[i]);                                  
 Event.observers[i][0] = null;                                                         
 }                                                                                     
 Event.observers = false;                                                              
 },                                                                                    
                                                                                       
 observe: function(element, name, observer, useCapture) {                              
 var element = $(element);                                                             
 useCapture = useCapture || false;                                                     
                                                                                       
 if (name == 'keypress' &&                                                             
 (navigator.appVersion.match(/Konqueror|Safari|KHTML/)                                 
 || element.attachEvent))                                                              
 name = 'keydown';                                                                     
                                                                                       
 this._observeAndCache(element, name, observer, useCapture);                           
 },                                                                                    
                                                                                       
 stopObserving: function(element, name, observer, useCapture) {                        
 var element = $(element);                                                             
 useCapture = useCapture || false;                                                     
                                                                                       
 if (name == 'keypress' &&                                                             
 (navigator.appVersion.match(/Konqueror|Safari|KHTML/)                                 
 || element.detachEvent))                                                              
 name = 'keydown';                                                                     
                                                                                       
 if (element.removeEventListener) {                                                    
 element.removeEventListener(name, observer, useCapture);                              
 } else if (element.detachEvent) {                                                     
 element.detachEvent('on' + name, observer);                                           
 }                                                                                     
 }                                                                                     
});                                                                                    
                                                                                       
/* prevent memory leaks in IE */                                                       
Event.observe(window, 'unload', Event.unloadCache, false);                             
var Position = {                                                                       
 // set to true if needed, warning: firefox performance problems                       
 // NOT neeeded for page scrolling, only if draggable contained in                     
 // scrollable elements                                                                
 includeScrollOffsets: false,                                                          
                                                                                       
 // must be called before calling withinIncludingScrolloffset, every time the          
 // page is scrolled                                                                   
 prepare: function() {                                                                 
 this.deltaX = window.pageXOffset                                                      
 || document.documentElement.scrollLeft                                                
 || document.body.scrollLeft                                                           
 || 0;                                                                                 
 this.deltaY = window.pageYOffset                                                      
 || document.documentElement.scrollTop                                                 
 || document.body.scrollTop                                                            
 || 0;                                                                                 
 },                                                                                    
                                                                                       
 realOffset: function(element) {                                                       
 var valueT = 0, valueL = 0;                                                           
 do {                                                                                  
 valueT += element.scrollTop || 0;                                                     
 valueL += element.scrollLeft || 0;                                                    
 element = element.parentNode;                                                         
 } while (element);                                                                    
 return [valueL, valueT];                                                              
 },                                                                                    
                                                                                       
 cumulativeOffset: function(element) {                                                 
 var valueT = 0, valueL = 0;                                                           
 do {                                                                                  
 valueT += element.offsetTop || 0;                                                     
 valueL += element.offsetLeft || 0;                                                    
 element = element.offsetParent;                                                       
 } while (element);                                                                    
 return [valueL, valueT];                                                              
 },                                                                                    
                                                                                       
 positionedOffset: function(element) {                                                 
 var valueT = 0, valueL = 0;                                                           
 do {                                                                                  
 valueT += element.offsetTop || 0;                                                     
 valueL += element.offsetLeft || 0;                                                    
 element = element.offsetParent;                                                       
 if (element) {                                                                        
 p = Element.getStyle(element, 'position');                                            
 if (p == 'relative' || p == 'absolute') break;                                        
 }                                                                                     
 } while (element);                                                                    
 return [valueL, valueT];                                                              
 },                                                                                    
                                                                                       
 offsetParent: function(element) {                                                     
 if (element.offsetParent) return element.offsetParent;                                
 if (element == document.body) return element;                                         
                                                                                       
 while ((element = element.parentNode) && element != document.body)                    
 if (Element.getStyle(element, 'position') != 'static')                                
 return element;                                                                       
                                                                                       
 return document.body;                                                                 
 },                                                                                    
                                                                                       
 // caches x/y coordinate pair to use with overlap                                     
 within: function(element, x, y) {                                                     
 if (this.includeScrollOffsets)                                                        
 return this.withinIncludingScrolloffsets(element, x, y);                              
 this.xcomp = x;                                                                       
 this.ycomp = y;                                                                       
 this.offset = this.cumulativeOffset(element);                                         
                                                                                       
 return (y >= this.offset[1] &&                                                        
 y < this.offset[1] + element.offsetHeight &&                                          
 x >= this.offset[0] &&                                                                
 x < this.offset[0] + element.offsetWidth);                                            
 },                                                                                    
                                                                                       
 withinIncludingScrolloffsets: function(element, x, y) {                               
 var offsetcache = this.realOffset(element);                                           
                                                                                       
 this.xcomp = x + offsetcache[0] - this.deltaX;                                        
 this.ycomp = y + offsetcache[1] - this.deltaY;                                        
 this.offset = this.cumulativeOffset(element);                                         
                                                                                       
 return (this.ycomp >= this.offset[1] &&                                               
 this.ycomp < this.offset[1] + element.offsetHeight &&                                 
 this.xcomp >= this.offset[0] &&                                                       
 this.xcomp < this.offset[0] + element.offsetWidth);                                   
 },                                                                                    
                                                                                       
 // within must be called directly before                                              
 overlap: function(mode, element) {                                                    
 if (!mode) return 0;                                                                  
 if (mode == 'vertical')                                                               
 return ((this.offset[1] + element.offsetHeight) - this.ycomp) /                       
 element.offsetHeight;                                                                 
 if (mode == 'horizontal')                                                             
 return ((this.offset[0] + element.offsetWidth) - this.xcomp) /                        
 element.offsetWidth;                                                                  
 },                                                                                    
                                                                                       
 clone: function(source, target) {                                                     
 source = $(source);                                                                   
 target = $(target);                                                                   
 target.style.position = 'absolute';                                                   
 var offsets = this.cumulativeOffset(source);                                          
 target.style.top = offsets[1] + 'px';                                                 
 target.style.left = offsets[0] + 'px';                                                
 target.style.width = source.offsetWidth + 'px';                                       
 target.style.height = source.offsetHeight + 'px';                                     
 },                                                                                    
                                                                                       
 page: function(forElement) {                                                          
 var valueT = 0, valueL = 0;                                                           
                                                                                       
 var element = forElement;                                                             
 do {                                                                                  
 valueT += element.offsetTop || 0;                                                     
 valueL += element.offsetLeft || 0;                                                    
                                                                                       
 // Safari fix                                                                         
 if (element.offsetParent==document.body)                                              
 if (Element.getStyle(element,'position')=='absolute') break;                          
                                                                                       
 } while (element = element.offsetParent);                                             
                                                                                       
 element = forElement;                                                                 
 do {                                                                                  
 valueT -= element.scrollTop || 0;                                                     
 valueL -= element.scrollLeft || 0;                                                    
 } while (element = element.parentNode);                                               
                                                                                       
 return [valueL, valueT];                                                              
 },                                                                                    
                                                                                       
 clone: function(source, target) {                                                     
 var options = Object.extend({                                                         
 setLeft: true,                                                                        
 setTop: true,                                                                         
 setWidth: true,                                                                       
 setHeight: true,                                                                      
 offsetTop: 0,                                                                         
 offsetLeft: 0                                                                         
 }, arguments[2] || {})                                                                
                                                                                       
 // find page position of source                                                       
 source = $(source);                                                                   
 var p = Position.page(source);                                                        
                                                                                       
 // find coordinate system to use                                                      
 target = $(target);                                                                   
 var delta = [0, 0];                                                                   
 var parent = null;                                                                    
 // delta [0,0] will do fine with position: fixed elements,                            
 // position:absolute needs offsetParent deltas                                        
 if (Element.getStyle(target,'position') == 'absolute') {                              
 parent = Position.offsetParent(target);                                               
 delta = Position.page(parent);                                                        
 }                                                                                     
                                                                                       
 // correct by body offsets (fixes Safari)                                             
 if (parent == document.body) {                                                        
 delta[0] -= document.body.offsetLeft;                                                 
 delta[1] -= document.body.offsetTop;                                                  
 }                                                                                     
                                                                                       
 // set position                                                                       
 if(options.setLeft) target.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
 if(options.setTop) target.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';   
 if(options.setWidth) target.style.width = source.offsetWidth + 'px';                  
 if(options.setHeight) target.style.height = source.offsetHeight + 'px';               
 },                                                                                    
                                                                                       
 absolutize: function(element) {                                                       
 element = $(element);                                                                 
 if (element.style.position == 'absolute') return;                                     
 Position.prepare();                                                                   
                                                                                       
 var offsets = Position.positionedOffset(element);                                     
 var top = offsets[1];                                                                 
 var left = offsets[0];                                                                
 var width = element.clientWidth;                                                      
 var height = element.clientHeight;                                                    
                                                                                       
 element._originalLeft = left - parseFloat(element.style.left || 0);                   
 element._originalTop = top - parseFloat(element.style.top || 0);                      
 element._originalWidth = element.style.width;                                         
 element._originalHeight = element.style.height;                                       
                                                                                       
 element.style.position = 'absolute';                                                  
 element.style.top = top + 'px';;                                                      
 element.style.left = left + 'px';;                                                    
 element.style.width = width + 'px';;                                                  
 element.style.height = height + 'px';;                                                
 },                                                                                    
                                                                                       
 relativize: function(element) {                                                       
 element = $(element);                                                                 
 if (element.style.position == 'relative') return;                                     
 Position.prepare();                                                                   
                                                                                       
 element.style.position = 'relative';                                                  
 var top = parseFloat(element.style.top || 0) - (element._originalTop || 0);           
 var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);        
                                                                                       
 element.style.top = top + 'px';                                                       
 element.style.left = left + 'px';                                                     
 element.style.height = element._originalHeight;                                       
 element.style.width = element._originalWidth;                                         
 }                                                                                     
}                                                                                      
                                                                                       
// Safari returns margins on body which is incorrect if the child is absolutely        
// positioned. For performance reasons, redefine Position.cumulativeOffset for         
// KHTML/WebKit only.                                                                  
if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)) {                              
 Position.cumulativeOffset = function(element) {                                       
 var valueT = 0, valueL = 0;                                                           
 do {                                                                                  
 valueT += element.offsetTop || 0;                                                     
 valueL += element.offsetLeft || 0;                                                    
 if (element.offsetParent == document.body)                                            
 if (Element.getStyle(element, 'position') == 'absolute') break;                       
                                                                                       
 element = element.offsetParent;                                                       
 } while (element);                                                                    
                                                                                       
 return [valueL, valueT];                                                              
 }                                                                                     
}