/*  Prototype JavaScript framework, version 1.3.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.3.0', 
   emptyFunction: function() {} 
 } 
  
 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.prototype.extend = function(object) { 
   return Object.extend.apply(this, [this, object]); 
 } 
 */ 
 Function.prototype.bind = function(object) { 
   var __method = this; 
   return function() { 
     __method.apply(object, arguments); 
   } 
 } 
  
 Function.prototype.bindAsEventListener = function(object) { 
   var __method = this; 
   return function(event) { 
     __method.call(object, event || window.event); 
   } 
 } 
  
 Number.prototype.toColorPart = function() { 
   var digits = this.toString(16); 
   if (this < 16) return '0' + digits; 
   return digits; 
 } 
  
 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; 
 } 
  
 if (!Array.prototype.push) { 
   Array.prototype.push = function() { 
                 var startLength = this.length; 
                 for (var i = 0; i < arguments.length; i++) 
       this[startLength + i] = arguments[i]; 
           return this.length; 
   } 
 } 
  
 if (!Function.prototype.apply) { 
   // Based on code from http://www.youngpup.net/ 
   Function.prototype.apply = function(object, parameters) { 
     var parameterStrings = new Array(); 
     if (!object)     object = window; 
     if (!parameters) parameters = new Array(); 
      
     for (var i = 0; i < parameters.length; i++) 
       parameterStrings[i] = 'parameters[' + i + ']'; 
      
     object.__apply__ = this; 
     var result = eval('object.__apply__(' +  
       parameterStrings[i].join(', ') + ')'); 
     object.__apply__ = null; 
      
     return result; 
   } 
 } 
  
 Object.extend(String.prototype, { 
   stripTags: function() { 
     return this.replace(/<\/?[^>]+>/gi, ''); 
   }, 
  
   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].nodeValue; 
   } 
 }); 
  
 var Ajax = { 
   getTransport: function() { 
     return Try.these( 
       function() {return new ActiveXObject('Msxml2.XMLHTTP')}, 
       function() {return new ActiveXObject('Microsoft.XMLHTTP')}, 
       function() {return new XMLHttpRequest()} 
     ) || false; 
   } 
 } 
  
 Ajax.Base = function() {}; 
 Ajax.Base.prototype = { 
   setOptions: function(options) { 
     this.options = Object.extend({ 
       method:       'post', 
       asynchronous: true, 
       parameters:   '' 
     }, 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 { 
       if (this.options.method == 'get') 
         url += '?' + parameters; 
  
       this.transport.open(this.options.method, 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) { 
     } 
   }, 
  
   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); 
   }, 
  
   respondToReadyState: function(readyState) { 
     var event = Ajax.Request.Events[readyState]; 
  
     if (event == 'Complete') 
       (this.options['on' + this.transport.status] 
        || this.options['on' + this.responseIsSuccess ? 'Success' : 'Failure'] 
        || Prototype.emptyFunction)(this.transport);        
  
     (this.options['on' + event] || Prototype.emptyFunction)(this.transport); 
  
     /* Avoid memory leak in MSIE: clean up the oncomplete event handler */ 
     if (event == 'Complete') 
       this.transport.onreadystatechange = Prototype.emptyFunction; 
   } 
 }); 
  
 Ajax.Updater = Class.create(); 
 Ajax.Updater.ScriptFragment = '(?:<script.*?>)((\n|.)*?)(?:<\/script>)'; 
  
 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() { 
       this.updateContent(); 
       onComplete(this.transport);       
     }).bind(this); 
  
     this.request(url); 
   }, 
  
   updateContent: function() { 
     var receiver = this.responseIsSuccess() ? 
       this.containers.success : this.containers.failure; 
  
     var match    = new RegExp(Ajax.Updater.ScriptFragment, 'img'); 
     var response = this.transport.responseText.replace(match, ''); 
     var scripts  = this.transport.responseText.match(match); 
  
     if (receiver) { 
       if (this.options.insertion) { 
         new this.options.insertion(receiver, response); 
       } else { 
         receiver.innerHTML = response; 
       } 
     } 
  
     if (this.responseIsSuccess()) { 
       if (this.onComplete) 
         setTimeout((function() {this.onComplete( 
           this.transport)}).bind(this), 10); 
     } 
  
     if (this.options.evalScripts && scripts) { 
       match = new RegExp(Ajax.Updater.ScriptFragment, 'im'); 
       setTimeout((function() { 
         for (var i = 0; i < scripts.length; i++) 
           eval(scripts[i].match(match)[1]); 
       }).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 = 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 || Ajax.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) { 
   var children = document.getElementsByTagName('*') || document.all; 
   var elements = new Array(); 
    
   for (var i = 0; i < children.length; i++) { 
     var child = children[i]; 
     var classNames = child.className.split(' '); 
     for (var j = 0; j < classNames.length; j++) { 
       if (classNames[j] == className) { 
         elements.push(child); 
         break; 
       } 
     } 
   } 
    
   return elements; 
 } 
  
 /*--------------------------------------------------------------------------*/ 
  
 if (!window.Element) { 
   var Element = new Object(); 
 } 
  
 Object.extend(Element, { 
   toggle: function() { 
     for (var i = 0; i < arguments.length; i++) { 
       var element = $(arguments[i]); 
       element.style.display =  
         (element.style.display == 'none' ? '' : 'none'); 
     } 
   }, 
  
   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); 
   }, 
     
   getHeight: function(element) { 
     element = $(element); 
     return element.offsetHeight;  
   }, 
  
   hasClassName: function(element, className) { 
     element = $(element); 
     if (!element) 
       return; 
     var a = element.className.split(' '); 
     for (var i = 0; i < a.length; i++) { 
       if (a[i] == className) 
         return true; 
     } 
     return false; 
   }, 
  
   addClassName: function(element, className) { 
     element = $(element); 
     Element.removeClassName(element, className); 
     element.className += ' ' + className; 
   }, 
  
   removeClassName: function(element, className) { 
     element = $(element); 
     if (!element) 
       return; 
     var newClassName = ''; 
     var a = element.className.split(' '); 
     for (var i = 0; i < a.length; i++) { 
       if (a[i] != className) { 
         if (i > 0) 
           newClassName += ' '; 
         newClassName += a[i]; 
       } 
     } 
     element.className = newClassName; 
   }, 
    
   // removes whitespace-only text node children 
   cleanWhitespace: function(element) { 
     var 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); 
     } 
   } 
 }); 
  
 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; 
      
     if (this.adjacency && this.element.insertAdjacentHTML) { 
       this.element.insertAdjacentHTML(this.adjacency, this.content); 
     } else { 
       this.range = this.element.ownerDocument.createRange(); 
       if (this.initializeRange) this.initializeRange(); 
       this.fragment = this.range.createContextualFragment(this.content); 
       this.insertContent(); 
     } 
   } 
 } 
  
 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() { 
     this.element.parentNode.insertBefore(this.fragment, this.element); 
   } 
 }); 
  
 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() {   
     this.element.insertBefore(this.fragment, this.element.firstChild); 
   } 
 }); 
  
 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() { 
     this.element.appendChild(this.fragment); 
   } 
 }); 
  
 Insertion.After = Class.create(); 
 Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), { 
   initializeRange: function() { 
     this.range.setStartAfter(this.element); 
   }, 
    
   insertContent: function() { 
     this.element.parentNode.insertBefore(this.fragment,  
       this.element.nextSibling); 
   } 
 }); 
  
 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).focus(); 
     $(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) { 
     var 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) { 
     var 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 = ''; 
     } 
   }, 
  
   focusFirstElement: function(form) { 
     var form = $(form); 
     var elements = Form.getElements(form); 
     for (var i = 0; i < elements.length; i++) { 
       var element = elements[i]; 
       if (element.type != 'hidden' && !element.disabled) { 
         Field.activate(element); 
         break; 
       } 
     } 
   }, 
  
   reset: function(form) { 
     $(form).reset(); 
   } 
 } 
  
 Form.Element = { 
   serialize: function(element) { 
     var element = $(element); 
     var method = element.tagName.toLowerCase(); 
     var parameter = Form.Element.Serializers[method](element); 
      
     if (parameter) 
       return encodeURIComponent(parameter[0]) + '=' +  
         encodeURIComponent(parameter[1]);                    
   }, 
    
   getValue: function(element) { 
     var 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) { 
     var value = ''; 
     if (element.type == 'select-one') { 
       var index = element.selectedIndex; 
       if (index >= 0) 
         value = element.options[index].value || element.options[index].text; 
     } else { 
       value = new Array(); 
       for (var i = 0; i < element.length; i++) { 
         var opt = element.options[i]; 
         if (opt.selected) 
           value.push(opt.value || opt.text); 
       } 
     } 
     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': 
           element.target = this; 
           element.prev_onclick = element.onclick || Prototype.emptyFunction; 
           element.onclick = function() { 
             this.prev_onclick();  
             this.target.onElementEvent(); 
           } 
           break; 
         case 'password': 
         case 'text': 
         case 'textarea': 
         case 'select-one': 
         case 'select-multiple': 
           element.target = this; 
           element.prev_onchange = element.onchange || Prototype.emptyFunction; 
           element.onchange = function() { 
             this.prev_onchange();  
             this.target.onElementEvent(); 
           } 
           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; 
     } 
   }, 
  
   // 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(Event.observers[i][0],Event.observers[i][1],Event.observers[i][2],Event.observers[i][3]); 
       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.indexOf('AppleWebKit') > 0) || 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.indexOf('AppleWebKit') > 0) || element.detachEvent)) 
         name = 'keydown'; 
      
     if (element.removeEventListener) { 
       element.removeEventListener(name, observer, useCapture); 
     } else if (element.detachEvent) { 
       element.detachEvent('on' + name, observer); 
     } 
   } 
 }); 
  
 // prevent memory leaks 
 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]; 
   }, 
  
   // 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'; 
   } 
 }