jro_apps/redmine Commit - r238:2e72f2eca8f4

updated prototype (1.50) and script.aculo.us javascripts...

Jean-Philippe Lang -

r238:2e72f2eca8f4

parent child

Context file:

r238:2e72f2eca8f4

Collapse all files

public/javascripts/controls.js +136 -53

-            // Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
+            // Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
-            //           (c) 2005 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
+            //           (c) 2005, 2006 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
-            //           (c) 2005 Jon Tirsen (http://www.tirsen.com)
+            //           (c) 2005, 2006 Jon Tirsen (http://www.tirsen.com)
             // Contributors:
             //  Richard Livsey
             //  Rahul Bhargava
             //  Rob Wills
             //
-            // See scriptaculous.js for full license.
+            // script.aculo.us is freely distributable under the terms of an MIT-style license.
+            // For details, see the script.aculo.us web site: http://script.aculo.us/
             // Autocompleter.Base handles all the autocompletion functionality
             // that's independent of the data source for autocompletion. This
             // includes drawing the autocompletion menu, observing keyboard
             // and mouse events, and similar.
             //
             // Specific autocompleters need to provide, at the very least,
             // a getUpdatedChoices function that will be invoked every time
             // the text inside the monitored textbox changes. This method
             // should get the text for which to provide autocompletion by
             // invoking this.getToken(), NOT by directly accessing
             // this.element.value. This is to allow incremental tokenized
             // autocompletion. Specific auto-completion logic (AJAX, etc)
             // belongs in getUpdatedChoices.
             //
             // Tokenized incremental autocompletion is enabled automatically
             // when an autocompleter is instantiated with the 'tokens' option
             // in the options parameter, e.g.:
             // new Ajax.Autocompleter('id','upd', '/url/', { tokens: ',' });
             // will incrementally autocomplete with a comma as the token.
             // Additionally, ',' in the above example can be replaced with
             // a token array, e.g. { tokens: [',', '\n'] } which
             // enables autocompletion on multiple tokens. This is most
             // useful when one of the tokens is \n (a newline), as it
             // allows smart autocompletion after linebreaks.
+            if(typeof Effect == 'undefined')
+              throw("controls.js requires including script.aculo.us' effects.js library");
             var Autocompleter = {}
             Autocompleter.Base = function() {};
             Autocompleter.Base.prototype = {
               baseInitialize: function(element, update, options) {
                 this.element     = $(element);
                 this.update      = $(update);
                 this.hasFocus    = false;
                 this.changed     = false;
                 this.active      = false;
                 this.index       = 0;
                 this.entryCount  = 0;
-                if (this.setOptions)
+                if(this.setOptions)
                   this.setOptions(options);
                 else
                   this.options = options || {};
                 this.options.paramName    = this.options.paramName || this.element.name;
                 this.options.tokens       = this.options.tokens || [];
                 this.options.frequency    = this.options.frequency || 0.4;
                 this.options.minChars     = this.options.minChars || 1;
                 this.options.onShow       = this.options.onShow ||
-                function(element, update){
+                  function(element, update){
-                  if(!update.style.position || update.style.position=='absolute') {
+                    if(!update.style.position || update.style.position=='absolute') {
-                    update.style.position = 'absolute';
+                      update.style.position = 'absolute';
-                    Position.clone(element, update, {setHeight: false, offsetTop: element.offsetHeight});
+                      Position.clone(element, update, {
+                        setHeight: false,
-                  Effect.Appear(update,{duration:0.15});
+                        offsetTop: element.offsetHeight
-                };
+                      });
+                    }
+                    Effect.Appear(update,{duration:0.15});
+                  };
                 this.options.onHide = this.options.onHide ||
-                function(element, update){ new Effect.Fade(update,{duration:0.15}) };
+                  function(element, update){ new Effect.Fade(update,{duration:0.15}) };
-                if (typeof(this.options.tokens) == 'string')
+                if(typeof(this.options.tokens) == 'string')
                   this.options.tokens = new Array(this.options.tokens);
                 this.observer = null;
                 this.element.setAttribute('autocomplete','off');
                 Element.hide(this.update);
                 Event.observe(this.element, "blur", this.onBlur.bindAsEventListener(this));
                 Event.observe(this.element, "keypress", this.onKeyPress.bindAsEventListener(this));
               },
               show: function() {
                 if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
                 if(!this.iefix &&
                   (navigator.appVersion.indexOf('MSIE')>0) &&
                   (navigator.userAgent.indexOf('Opera')<0) &&
                   (Element.getStyle(this.update, 'position')=='absolute')) {
                   new Insertion.After(this.update,
                    '<iframe id="' + this.update.id + '_iefix" '+
                    'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +
                    'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');
                   this.iefix = $(this.update.id+'_iefix');
                 }
                 if(this.iefix) setTimeout(this.fixIEOverlapping.bind(this), 50);
               },
               fixIEOverlapping: function() {
-                Position.clone(this.update, this.iefix);
+                Position.clone(this.update, this.iefix, {setTop:(!this.update.style.height)});
                 this.iefix.style.zIndex = 1;
                 this.update.style.zIndex = 2;
                 Element.show(this.iefix);
               },
               hide: function() {
                 this.stopIndicator();
                 if(Element.getStyle(this.update, 'display')!='none') this.options.onHide(this.element, this.update);
                 if(this.iefix) Element.hide(this.iefix);
               },
               startIndicator: function() {
                 if(this.options.indicator) Element.show(this.options.indicator);
               },
               stopIndicator: function() {
                 if(this.options.indicator) Element.hide(this.options.indicator);
               },
               onKeyPress: function(event) {
                 if(this.active)
                   switch(event.keyCode) {
                    case Event.KEY_TAB:
                    case Event.KEY_RETURN:
                      this.selectEntry();
                      Event.stop(event);
                    case Event.KEY_ESC:
                      this.hide();
                      this.active = false;
                      Event.stop(event);
                      return;
                    case Event.KEY_LEFT:
                    case Event.KEY_RIGHT:
                      return;
                    case Event.KEY_UP:
                      this.markPrevious();
                      this.render();
                      if(navigator.appVersion.indexOf('AppleWebKit')>0) Event.stop(event);
                      return;
                    case Event.KEY_DOWN:
                      this.markNext();
                      this.render();
                      if(navigator.appVersion.indexOf('AppleWebKit')>0) Event.stop(event);
                      return;
                   }
                  else
-                  if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN)
+                   if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN ||
-                    return;
+                     (navigator.appVersion.indexOf('AppleWebKit') > 0 && event.keyCode == 0)) return;
                 this.changed = true;
                 this.hasFocus = true;
                 if(this.observer) clearTimeout(this.observer);
                   this.observer =
                     setTimeout(this.onObserverEvent.bind(this), this.options.frequency*1000);
               },
+              activate: function() {
+                this.changed = false;
+                this.hasFocus = true;
+                this.getUpdatedChoices();
+              },
               onHover: function(event) {
                 var element = Event.findElement(event, 'LI');
                 if(this.index != element.autocompleteIndex)
                 {
                     this.index = element.autocompleteIndex;
                     this.render();
                 }
                 Event.stop(event);
               },
               onClick: function(event) {
                 var element = Event.findElement(event, 'LI');
                 this.index = element.autocompleteIndex;
                 this.selectEntry();
                 this.hide();
               },
               onBlur: function(event) {
                 // needed to make click events working
                 setTimeout(this.hide.bind(this), 250);
                 this.hasFocus = false;
                 this.active = false;
               },
               render: function() {
                 if(this.entryCount > 0) {
                   for (var i = 0; i < this.entryCount; i++)
                     this.index==i ?
                       Element.addClassName(this.getEntry(i),"selected") :
                       Element.removeClassName(this.getEntry(i),"selected");
                   if(this.hasFocus) {
                     this.show();
                     this.active = true;
                   }
                 } else {
                   this.active = false;
                   this.hide();
                 }
               },
               markPrevious: function() {
                 if(this.index > 0) this.index--
                   else this.index = this.entryCount-1;
+                this.getEntry(this.index).scrollIntoView(true);
               },
               markNext: function() {
                 if(this.index < this.entryCount-1) this.index++
                   else this.index = 0;
+                this.getEntry(this.index).scrollIntoView(false);
               },
               getEntry: function(index) {
                 return this.update.firstChild.childNodes[index];
               },
               getCurrentEntry: function() {
                 return this.getEntry(this.index);
               },
               selectEntry: function() {
                 this.active = false;
                 this.updateElement(this.getCurrentEntry());
               },
               updateElement: function(selectedElement) {
                 if (this.options.updateElement) {
                   this.options.updateElement(selectedElement);
                   return;
                 }
+                var value = '';
-                var value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');
+                if (this.options.select) {
+                  var nodes = document.getElementsByClassName(this.options.select, selectedElement) || [];
+                  if(nodes.length>0) value = Element.collectTextNodes(nodes[0], this.options.select);
+                } else
+                  value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');
                 var lastTokenPos = this.findLastToken();
                 if (lastTokenPos != -1) {
                   var newValue = this.element.value.substr(0, lastTokenPos + 1);
                   var whitespace = this.element.value.substr(lastTokenPos + 1).match(/^\s+/);
                   if (whitespace)
                     newValue += whitespace[0];
                   this.element.value = newValue + value;
                 } else {
                   this.element.value = value;
                 }
                 this.element.focus();
                 if (this.options.afterUpdateElement)
                   this.options.afterUpdateElement(this.element, selectedElement);
               },
               updateChoices: function(choices) {
                 if(!this.changed && this.hasFocus) {
                   this.update.innerHTML = choices;
                   Element.cleanWhitespace(this.update);
-                  Element.cleanWhitespace(this.update.firstChild);
+                  Element.cleanWhitespace(this.update.down());
-                  if(this.update.firstChild && this.update.firstChild.childNodes) {
+                  if(this.update.firstChild && this.update.down().childNodes) {
                     this.entryCount =
-                      this.update.firstChild.childNodes.length;
+                      this.update.down().childNodes.length;
                     for (var i = 0; i < this.entryCount; i++) {
                       var entry = this.getEntry(i);
                       entry.autocompleteIndex = i;
                       this.addObservers(entry);
                     }
                   } else {
                     this.entryCount = 0;
                   }
                   this.stopIndicator();
                   this.index = 0;
-                  this.render();
+                  if(this.entryCount==1 && this.options.autoSelect) {
+                    this.selectEntry();
+                    this.hide();
+                  } else {
+                    this.render();
+                  }
                 }
               },
               addObservers: function(element) {
                 Event.observe(element, "mouseover", this.onHover.bindAsEventListener(this));
                 Event.observe(element, "click", this.onClick.bindAsEventListener(this));
               },
               onObserverEvent: function() {
                 this.changed = false;
                 if(this.getToken().length>=this.options.minChars) {
                   this.startIndicator();
                   this.getUpdatedChoices();
                 } else {
                   this.active = false;
                   this.hide();
                 }
               },
               getToken: function() {
                 var tokenPos = this.findLastToken();
                 if (tokenPos != -1)
                   var ret = this.element.value.substr(tokenPos + 1).replace(/^\s+/,'').replace(/\s+$/,'');
                 else
                   var ret = this.element.value;
                 return /\n/.test(ret) ? '' : ret;
               },
               findLastToken: function() {
                 var lastTokenPos = -1;
                 for (var i=0; i<this.options.tokens.length; i++) {
                   var thisTokenPos = this.element.value.lastIndexOf(this.options.tokens[i]);
                   if (thisTokenPos > lastTokenPos)
                     lastTokenPos = thisTokenPos;
                 }
                 return lastTokenPos;
               }
             }
             Ajax.Autocompleter = Class.create();
             Object.extend(Object.extend(Ajax.Autocompleter.prototype, Autocompleter.Base.prototype), {
               initialize: function(element, update, url, options) {
-            	  this.baseInitialize(element, update, options);
+                this.baseInitialize(element, update, options);
                 this.options.asynchronous  = true;
                 this.options.onComplete    = this.onComplete.bind(this);
                 this.options.defaultParams = this.options.parameters || null;
                 this.url                   = url;
               },
               getUpdatedChoices: function() {
                 entry = encodeURIComponent(this.options.paramName) + '=' +
                   encodeURIComponent(this.getToken());
                 this.options.parameters = this.options.callback ?
                   this.options.callback(this.element, entry) : entry;
                 if(this.options.defaultParams)
                   this.options.parameters += '&' + this.options.defaultParams;
                 new Ajax.Request(this.url, this.options);
               },
               onComplete: function(request) {
                 this.updateChoices(request.responseText);
               }
             });
             // The local array autocompleter. Used when you'd prefer to
             // inject an array of autocompletion options into the page, rather
             // than sending out Ajax queries, which can be quite slow sometimes.
             //
             // The constructor takes four parameters. The first two are, as usual,
             // the id of the monitored textbox, and id of the autocompletion menu.
             // The third is the array you want to autocomplete from, and the fourth
             // is the options block.
             //
             // Extra local autocompletion options:
             // - choices - How many autocompletion choices to offer
             //
             // - partialSearch - If false, the autocompleter will match entered
             //                    text only at the beginning of strings in the
             //                    autocomplete array. Defaults to true, which will
             //                    match text at the beginning of any *word* in the
             //                    strings in the autocomplete array. If you want to
             //                    search anywhere in the string, additionally set
             //                    the option fullSearch to true (default: off).
             //
             // - fullSsearch - Search anywhere in autocomplete array strings.
             //
             // - partialChars - How many characters to enter before triggering
             //                   a partial match (unlike minChars, which defines
             //                   how many characters are required to do any match
             //                   at all). Defaults to 2.
             //
             // - ignoreCase - Whether to ignore case when autocompleting.
             //                 Defaults to true.
             //
             // It's possible to pass in a custom function as the 'selector'
             // option, if you prefer to write your own autocompletion logic.
             // In that case, the other options above will not apply unless
             // you support them.
             Autocompleter.Local = Class.create();
             Autocompleter.Local.prototype = Object.extend(new Autocompleter.Base(), {
               initialize: function(element, update, array, options) {
                 this.baseInitialize(element, update, options);
                 this.options.array = array;
               },
               getUpdatedChoices: function() {
                 this.updateChoices(this.options.selector(this));
               },
               setOptions: function(options) {
                 this.options = Object.extend({
                   choices: 10,
                   partialSearch: true,
                   partialChars: 2,
                   ignoreCase: true,
                   fullSearch: false,
                   selector: function(instance) {
                     var ret       = []; // Beginning matches
                     var partial   = []; // Inside matches
                     var entry     = instance.getToken();
                     var count     = 0;
                     for (var i = 0; i < instance.options.array.length &&
                       ret.length < instance.options.choices ; i++) {
                       var elem = instance.options.array[i];
                       var foundPos = instance.options.ignoreCase ?
                         elem.toLowerCase().indexOf(entry.toLowerCase()) :
                         elem.indexOf(entry);
                       while (foundPos != -1) {
                         if (foundPos == 0 && elem.length != entry.length) {
                           ret.push("<li><strong>" + elem.substr(0, entry.length) + "</strong>" +
                             elem.substr(entry.length) + "</li>");
                           break;
                         } else if (entry.length >= instance.options.partialChars &&
                           instance.options.partialSearch && foundPos != -1) {
                           if (instance.options.fullSearch || /\s/.test(elem.substr(foundPos-1,1))) {
                             partial.push("<li>" + elem.substr(0, foundPos) + "<strong>" +
                               elem.substr(foundPos, entry.length) + "</strong>" + elem.substr(
                               foundPos + entry.length) + "</li>");
                             break;
                           }
                         }
                         foundPos = instance.options.ignoreCase ?
                           elem.toLowerCase().indexOf(entry.toLowerCase(), foundPos + 1) :
                           elem.indexOf(entry, foundPos + 1);
                       }
                     }
                     if (partial.length)
                       ret = ret.concat(partial.slice(0, instance.options.choices - ret.length))
                     return "<ul>" + ret.join('') + "</ul>";
                   }
                 }, options || {});
               }
             });
             // AJAX in-place editor
             //
             // see documentation on http://wiki.script.aculo.us/scriptaculous/show/Ajax.InPlaceEditor
             // Use this if you notice weird scrolling problems on some browsers,
             // the DOM might be a bit confused when this gets called so do this
             // waits 1 ms (with setTimeout) until it does the activation
             Field.scrollFreeActivate = function(field) {
               setTimeout(function() {
                 Field.activate(field);
               }, 1);
             }
             Ajax.InPlaceEditor = Class.create();
             Ajax.InPlaceEditor.defaultHighlightColor = "#FFFF99";
             Ajax.InPlaceEditor.prototype = {
               initialize: function(element, url, options) {
                 this.url = url;
                 this.element = $(element);
                 this.options = Object.extend({
+                  paramName: "value",
+                  okButton: true,
                   okText: "ok",
+                  cancelLink: true,
                   cancelText: "cancel",
                   savingText: "Saving...",
                   clickToEditText: "Click to edit",
                   okText: "ok",
                   rows: 1,
                   onComplete: function(transport, element) {
                     new Effect.Highlight(element, {startcolor: this.options.highlightcolor});
                   },
                   onFailure: function(transport) {
                     alert("Error communicating with the server: " + transport.responseText.stripTags());
                   },
                   callback: function(form) {
                     return Form.serialize(form);
                   },
                   handleLineBreaks: true,
                   loadingText: 'Loading...',
                   savingClassName: 'inplaceeditor-saving',
                   loadingClassName: 'inplaceeditor-loading',
                   formClassName: 'inplaceeditor-form',
                   highlightcolor: Ajax.InPlaceEditor.defaultHighlightColor,
                   highlightendcolor: "#FFFFFF",
-                  externalControl:	null,
+                  externalControl: null,
-                  ajaxOptions: {}
+                  submitOnBlur: false,
+                  ajaxOptions: {},
+                  evalScripts: false
                 }, options || {});
                 if(!this.options.formId && this.element.id) {
                   this.options.formId = this.element.id + "-inplaceeditor";
                   if ($(this.options.formId)) {
                     // there's already a form with that name, don't specify an id
                     this.options.formId = null;
                   }
                 }
                 if (this.options.externalControl) {
                   this.options.externalControl = $(this.options.externalControl);
                 }
                 this.originalBackground = Element.getStyle(this.element, 'background-color');
                 if (!this.originalBackground) {
                   this.originalBackground = "transparent";
                 }
                 this.element.title = this.options.clickToEditText;
                 this.onclickListener = this.enterEditMode.bindAsEventListener(this);
                 this.mouseoverListener = this.enterHover.bindAsEventListener(this);
                 this.mouseoutListener = this.leaveHover.bindAsEventListener(this);
                 Event.observe(this.element, 'click', this.onclickListener);
                 Event.observe(this.element, 'mouseover', this.mouseoverListener);
                 Event.observe(this.element, 'mouseout', this.mouseoutListener);
                 if (this.options.externalControl) {
                   Event.observe(this.options.externalControl, 'click', this.onclickListener);
                   Event.observe(this.options.externalControl, 'mouseover', this.mouseoverListener);
                   Event.observe(this.options.externalControl, 'mouseout', this.mouseoutListener);
                 }
               },
               enterEditMode: function(evt) {
                 if (this.saving) return;
                 if (this.editing) return;
                 this.editing = true;
                 this.onEnterEditMode();
                 if (this.options.externalControl) {
                   Element.hide(this.options.externalControl);
                 }
                 Element.hide(this.element);
                 this.createForm();
                 this.element.parentNode.insertBefore(this.form, this.element);
-                Field.scrollFreeActivate(this.editField);
+                if (!this.options.loadTextURL) Field.scrollFreeActivate(this.editField);
                 // stop the event to avoid a page refresh in Safari
                 if (evt) {
                   Event.stop(evt);
                 }
                 return false;
               },
               createForm: function() {
                 this.form = document.createElement("form");
                 this.form.id = this.options.formId;
                 Element.addClassName(this.form, this.options.formClassName)
                 this.form.onsubmit = this.onSubmit.bind(this);
                 this.createEditField();
                 if (this.options.textarea) {
                   var br = document.createElement("br");
                   this.form.appendChild(br);
                 }
-                okButton = document.createElement("input");
+                if (this.options.okButton) {
-                okButton.type = "submit";
+                  okButton = document.createElement("input");
-                okButton.value = this.options.okText;
+                  okButton.type = "submit";
-                this.form.appendChild(okButton);
+                  okButton.value = this.options.okText;
+                  okButton.className = 'editor_ok_button';
+                  this.form.appendChild(okButton);
+                }
-                cancelLink = document.createElement("a");
+                if (this.options.cancelLink) {
-                cancelLink.href = "#";
+                  cancelLink = document.createElement("a");
-                cancelLink.appendChild(document.createTextNode(this.options.cancelText));
+                  cancelLink.href = "#";
-                cancelLink.onclick = this.onclickCancel.bind(this);
+                  cancelLink.appendChild(document.createTextNode(this.options.cancelText));
-                this.form.appendChild(cancelLink);
+                  cancelLink.onclick = this.onclickCancel.bind(this);
+                  cancelLink.className = 'editor_cancel';
+                  this.form.appendChild(cancelLink);
+                }
               },
               hasHTMLLineBreaks: function(string) {
                 if (!this.options.handleLineBreaks) return false;
                 return string.match(/<br/i) || string.match(/<p>/i);
               },
               convertHTMLLineBreaks: function(string) {
                 return string.replace(/<br>/gi, "\n").replace(/<br\/>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<p>/gi, "");
               },
               createEditField: function() {
                 var text;
                 if(this.options.loadTextURL) {
                   text = this.options.loadingText;
                 } else {
                   text = this.getText();
                 }
+                var obj = this;
                 if (this.options.rows == 1 && !this.hasHTMLLineBreaks(text)) {
                   this.options.textarea = false;
                   var textField = document.createElement("input");
+                  textField.obj = this;
                   textField.type = "text";
-                  textField.name = "value";
+                  textField.name = this.options.paramName;
                   textField.value = text;
                   textField.style.backgroundColor = this.options.highlightcolor;
+                  textField.className = 'editor_field';
                   var size = this.options.size || this.options.cols || 0;
                   if (size != 0) textField.size = size;
+                  if (this.options.submitOnBlur)
+                    textField.onblur = this.onSubmit.bind(this);
                   this.editField = textField;
                 } else {
                   this.options.textarea = true;
                   var textArea = document.createElement("textarea");
-                  textArea.name = "value";
+                  textArea.obj = this;
+                  textArea.name = this.options.paramName;
                   textArea.value = this.convertHTMLLineBreaks(text);
                   textArea.rows = this.options.rows;
                   textArea.cols = this.options.cols || 40;
+                  textArea.className = 'editor_field';
+                  if (this.options.submitOnBlur)
+                    textArea.onblur = this.onSubmit.bind(this);
                   this.editField = textArea;
                 }
                 if(this.options.loadTextURL) {
                   this.loadExternalText();
                 }
                 this.form.appendChild(this.editField);
               },
               getText: function() {
                 return this.element.innerHTML;
               },
               loadExternalText: function() {
                 Element.addClassName(this.form, this.options.loadingClassName);
                 this.editField.disabled = true;
                 new Ajax.Request(
                   this.options.loadTextURL,
                   Object.extend({
                     asynchronous: true,
                     onComplete: this.onLoadedExternalText.bind(this)
                   }, this.options.ajaxOptions)
                 );
               },
               onLoadedExternalText: function(transport) {
                 Element.removeClassName(this.form, this.options.loadingClassName);
                 this.editField.disabled = false;
                 this.editField.value = transport.responseText.stripTags();
+                Field.scrollFreeActivate(this.editField);
               },
               onclickCancel: function() {
                 this.onComplete();
                 this.leaveEditMode();
                 return false;
               },
               onFailure: function(transport) {
                 this.options.onFailure(transport);
                 if (this.oldInnerHTML) {
                   this.element.innerHTML = this.oldInnerHTML;
                   this.oldInnerHTML = null;
                 }
                 return false;
               },
               onSubmit: function() {
                 // onLoading resets these so we need to save them away for the Ajax call
                 var form = this.form;
                 var value = this.editField.value;
                 // do this first, sometimes the ajax call returns before we get a chance to switch on Saving...
                 // which means this will actually switch on Saving... *after* we've left edit mode causing Saving...
                 // to be displayed indefinitely
                 this.onLoading();
-                new Ajax.Updater(
+                if (this.options.evalScripts) {
+                  new Ajax.Request(
-                    success: this.element,
+                    this.url, Object.extend({
-                     // don't update on failure (this could be an option)
+                      parameters: this.options.callback(form, value),
-                    failure: null
+                      onComplete: this.onComplete.bind(this),
-                  },
+                      onFailure: this.onFailure.bind(this),
-                  this.url,
+                      asynchronous:true,
-                  Object.extend({
+                      evalScripts:true
-                    parameters: this.options.callback(form, value),
+                    }, this.options.ajaxOptions));
-                    onComplete: this.onComplete.bind(this),
+                } else  {
-                    onFailure: this.onFailure.bind(this)
+                  new Ajax.Updater(
-                  }, this.options.ajaxOptions)
+                    { success: this.element,
-                );
+                      // don't update on failure (this could be an option)
+                      failure: null },
+                    this.url, Object.extend({
+                      parameters: this.options.callback(form, value),
+                      onComplete: this.onComplete.bind(this),
+                      onFailure: this.onFailure.bind(this)
+                    }, this.options.ajaxOptions));
+                }
                 // stop the event to avoid a page refresh in Safari
                 if (arguments.length > 1) {
                   Event.stop(arguments[0]);
                 }
                 return false;
               },
               onLoading: function() {
                 this.saving = true;
                 this.removeForm();
                 this.leaveHover();
                 this.showSaving();
               },
               showSaving: function() {
                 this.oldInnerHTML = this.element.innerHTML;
                 this.element.innerHTML = this.options.savingText;
                 Element.addClassName(this.element, this.options.savingClassName);
                 this.element.style.backgroundColor = this.originalBackground;
                 Element.show(this.element);
               },
               removeForm: function() {
                 if(this.form) {
                   if (this.form.parentNode) Element.remove(this.form);
                   this.form = null;
                 }
               },
               enterHover: function() {
                 if (this.saving) return;
                 this.element.style.backgroundColor = this.options.highlightcolor;
                 if (this.effect) {
                   this.effect.cancel();
                 }
                 Element.addClassName(this.element, this.options.hoverClassName)
               },
               leaveHover: function() {
                 if (this.options.backgroundColor) {
                   this.element.style.backgroundColor = this.oldBackground;
                 }
                 Element.removeClassName(this.element, this.options.hoverClassName)
                 if (this.saving) return;
                 this.effect = new Effect.Highlight(this.element, {
                   startcolor: this.options.highlightcolor,
                   endcolor: this.options.highlightendcolor,
                   restorecolor: this.originalBackground
                 });
               },
               leaveEditMode: function() {
                 Element.removeClassName(this.element, this.options.savingClassName);
                 this.removeForm();
                 this.leaveHover();
                 this.element.style.backgroundColor = this.originalBackground;
                 Element.show(this.element);
                 if (this.options.externalControl) {
                   Element.show(this.options.externalControl);
                 }
                 this.editing = false;
                 this.saving = false;
                 this.oldInnerHTML = null;
                 this.onLeaveEditMode();
               },
               onComplete: function(transport) {
                 this.leaveEditMode();
                 this.options.onComplete.bind(this)(transport, this.element);
               },
               onEnterEditMode: function() {},
               onLeaveEditMode: function() {},
               dispose: function() {
                 if (this.oldInnerHTML) {
                   this.element.innerHTML = this.oldInnerHTML;
                 }
                 this.leaveEditMode();
                 Event.stopObserving(this.element, 'click', this.onclickListener);
                 Event.stopObserving(this.element, 'mouseover', this.mouseoverListener);
                 Event.stopObserving(this.element, 'mouseout', this.mouseoutListener);
                 if (this.options.externalControl) {
                   Event.stopObserving(this.options.externalControl, 'click', this.onclickListener);
                   Event.stopObserving(this.options.externalControl, 'mouseover', this.mouseoverListener);
                   Event.stopObserving(this.options.externalControl, 'mouseout', this.mouseoutListener);
                 }
               }
             };
+            Ajax.InPlaceCollectionEditor = Class.create();
+            Object.extend(Ajax.InPlaceCollectionEditor.prototype, Ajax.InPlaceEditor.prototype);
+            Object.extend(Ajax.InPlaceCollectionEditor.prototype, {
+              createEditField: function() {
+                if (!this.cached_selectTag) {
+                  var selectTag = document.createElement("select");
+                  var collection = this.options.collection || [];
+                  var optionTag;
+                  collection.each(function(e,i) {
+                    optionTag = document.createElement("option");
+                    optionTag.value = (e instanceof Array) ? e[0] : e;
+                    if((typeof this.options.value == 'undefined') &&
+                      ((e instanceof Array) ? this.element.innerHTML == e[1] : e == optionTag.value)) optionTag.selected = true;
+                    if(this.options.value==optionTag.value) optionTag.selected = true;
+                    optionTag.appendChild(document.createTextNode((e instanceof Array) ? e[1] : e));
+                    selectTag.appendChild(optionTag);
+                  }.bind(this));
+                  this.cached_selectTag = selectTag;
+                }
+                this.editField = this.cached_selectTag;
+                if(this.options.loadTextURL) this.loadExternalText();
+                this.form.appendChild(this.editField);
+                this.options.callback = function(form, value) {
+                  return "value=" + encodeURIComponent(value);
+                }
+              }
+            });
             // Delayed observer, like Form.Element.Observer,
             // but waits for delay after last key input
             // Ideal for live-search fields
             Form.Element.DelayedObserver = Class.create();
             Form.Element.DelayedObserver.prototype = {
               initialize: function(element, delay, callback) {
                 this.delay     = delay || 0.5;
                 this.element   = $(element);
                 this.callback  = callback;
                 this.timer     = null;
                 this.lastValue = $F(this.element);
                 Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
               },
               delayedListener: function(event) {
                 if(this.lastValue == $F(this.element)) return;
                 if(this.timer) clearTimeout(this.timer);
                 this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
                 this.lastValue = $F(this.element);
               },
               onTimerEvent: function() {
                 this.timer = null;
                 this.callback(this.element, $F(this.element));
               }
-            };
  No newline at end of file
+            };

public/javascripts/dragdrop.js +454 -96

-            // Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
+            // Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
+            //           (c) 2005, 2006 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
             //
-            // See scriptaculous.js for full license.
+            // script.aculo.us is freely distributable under the terms of an MIT-style license.
+            // For details, see the script.aculo.us web site: http://script.aculo.us/
-            /*--------------------------------------------------------------------------*/
+            if(typeof Effect == 'undefined')
+              throw("dragdrop.js requires including script.aculo.us' effects.js library");
             var Droppables = {
               drops: [],
               remove: function(element) {
                 this.drops = this.drops.reject(function(d) { return d.element==$(element) });
               },
               add: function(element) {
                 element = $(element);
                 var options = Object.extend({
                   greedy:     true,
-                  hoverclass: null
+                  hoverclass: null,
+                  tree:       false
                 }, arguments[1] || {});
                 // cache containers
                 if(options.containment) {
                   options._containers = [];
                   var containment = options.containment;
                   if((typeof containment == 'object') &&
                     (containment.constructor == Array)) {
                     containment.each( function(c) { options._containers.push($(c)) });
                   } else {
                     options._containers.push($(containment));
                   }
                 }
                 if(options.accept) options.accept = [options.accept].flatten();
                 Element.makePositioned(element); // fix IE
                 options.element = element;
                 this.drops.push(options);
               },
+              findDeepestChild: function(drops) {
+                deepest = drops[0];
+                for (i = 1; i < drops.length; ++i)
+                  if (Element.isParent(drops[i].element, deepest.element))
+                    deepest = drops[i];
+                return deepest;
+              },
               isContained: function(element, drop) {
-                var parentNode = element.parentNode;
+                var containmentNode;
-                return drop._containers.detect(function(c) { return parentNode == c });
+                if(drop.tree) {
+                  containmentNode = element.treeNode;
+                } else {
+                  containmentNode = element.parentNode;
+                }
+                return drop._containers.detect(function(c) { return containmentNode == c });
               },
               isAffected: function(point, element, drop) {
                 return (
                   (drop.element!=element) &&
                   ((!drop._containers) ||
                     this.isContained(element, drop)) &&
                   ((!drop.accept) ||
                     (Element.classNames(element).detect(
                       function(v) { return drop.accept.include(v) } ) )) &&
                   Position.within(drop.element, point[0], point[1]) );
               },
               deactivate: function(drop) {
                 if(drop.hoverclass)
                   Element.removeClassName(drop.element, drop.hoverclass);
                 this.last_active = null;
               },
               activate: function(drop) {
                 if(drop.hoverclass)
                   Element.addClassName(drop.element, drop.hoverclass);
                 this.last_active = drop;
               },
               show: function(point, element) {
                 if(!this.drops.length) return;
+                var affected = [];
                 if(this.last_active) this.deactivate(this.last_active);
                 this.drops.each( function(drop) {
-                  if(Droppables.isAffected(point, element, drop)) {
+                  if(Droppables.isAffected(point, element, drop))
-                    if(drop.onHover)
+                    affected.push(drop);
-                       drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
-                    if(drop.greedy) {
-                      Droppables.activate(drop);
-                      throw $break;
                 });
+                if(affected.length>0) {
+                  drop = Droppables.findDeepestChild(affected);
+                  Position.within(drop.element, point[0], point[1]);
+                  if(drop.onHover)
+                    drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
+                  Droppables.activate(drop);
+                }
               },
               fire: function(event, element) {
                 if(!this.last_active) return;
                 Position.prepare();
                 if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
                   if (this.last_active.onDrop)
                     this.last_active.onDrop(element, this.last_active.element, event);
               },
               reset: function() {
                 if(this.last_active)
                   this.deactivate(this.last_active);
               }
             }
             var Draggables = {
               drags: [],
               observers: [],
               register: function(draggable) {
                 if(this.drags.length == 0) {
                   this.eventMouseUp   = this.endDrag.bindAsEventListener(this);
                   this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
                   this.eventKeypress  = this.keyPress.bindAsEventListener(this);
                   Event.observe(document, "mouseup", this.eventMouseUp);
                   Event.observe(document, "mousemove", this.eventMouseMove);
                   Event.observe(document, "keypress", this.eventKeypress);
                 }
                 this.drags.push(draggable);
               },
               unregister: function(draggable) {
                 this.drags = this.drags.reject(function(d) { return d==draggable });
                 if(this.drags.length == 0) {
                   Event.stopObserving(document, "mouseup", this.eventMouseUp);
                   Event.stopObserving(document, "mousemove", this.eventMouseMove);
                   Event.stopObserving(document, "keypress", this.eventKeypress);
                 }
               },
               activate: function(draggable) {
-                window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
+                if(draggable.options.delay) {
-                this.activeDraggable = draggable;
+                  this._timeout = setTimeout(function() {
+                    Draggables._timeout = null;
+                    window.focus();
+                    Draggables.activeDraggable = draggable;
+                  }.bind(this), draggable.options.delay);
+                } else {
+                  window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
+                  this.activeDraggable = draggable;
+                }
               },
-              deactivate: function(draggbale) {
+              deactivate: function() {
                 this.activeDraggable = null;
               },
               updateDrag: function(event) {
                 if(!this.activeDraggable) return;
                 var pointer = [Event.pointerX(event), Event.pointerY(event)];
                 // Mozilla-based browsers fire successive mousemove events with
                 // the same coordinates, prevent needless redrawing (moz bug?)
                 if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
                 this._lastPointer = pointer;
                 this.activeDraggable.updateDrag(event, pointer);
               },
               endDrag: function(event) {
+                if(this._timeout) {
+                  clearTimeout(this._timeout);
+                  this._timeout = null;
+                }
                 if(!this.activeDraggable) return;
                 this._lastPointer = null;
                 this.activeDraggable.endDrag(event);
+                this.activeDraggable = null;
               },
               keyPress: function(event) {
                 if(this.activeDraggable)
                   this.activeDraggable.keyPress(event);
               },
               addObserver: function(observer) {
                 this.observers.push(observer);
                 this._cacheObserverCallbacks();
               },
               removeObserver: function(element) {  // element instead of observer fixes mem leaks
                 this.observers = this.observers.reject( function(o) { return o.element==element });
                 this._cacheObserverCallbacks();
               },
               notify: function(eventName, draggable, event) {  // 'onStart', 'onEnd', 'onDrag'
                 if(this[eventName+'Count'] > 0)
                   this.observers.each( function(o) {
                     if(o[eventName]) o[eventName](eventName, draggable, event);
                   });
+                if(draggable.options[eventName]) draggable.options[eventName](draggable, event);
               },
               _cacheObserverCallbacks: function() {
                 ['onStart','onEnd','onDrag'].each( function(eventName) {
                   Draggables[eventName+'Count'] = Draggables.observers.select(
                     function(o) { return o[eventName]; }
                   ).length;
                 });
               }
             }
             /*--------------------------------------------------------------------------*/
             var Draggable = Class.create();
+            Draggable._dragging    = {};
             Draggable.prototype = {
               initialize: function(element) {
-                var options = Object.extend({
+                var defaults = {
                   handle: false,
-                  starteffect: function(element) {
-                    new Effect.Opacity(element, {duration:0.2, from:1.0, to:0.7});
-                  },
                   reverteffect: function(element, top_offset, left_offset) {
                     var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
-                    element._revert = new Effect.MoveBy(element, -top_offset, -left_offset, {duration:dur});
+                    new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur,
+                      queue: {scope:'_draggable', position:'end'}
+                    });
                   },
                   endeffect: function(element) {
-                    new Effect.Opacity(element, {duration:0.2, from:0.7, to:1.0});
+                    var toOpacity = typeof element._opacity == 'number' ? element._opacity : 1.0;
+                    new Effect.Opacity(element, {duration:0.2, from:0.7, to:toOpacity,
+                      queue: {scope:'_draggable', position:'end'},
+                      afterFinish: function(){
+                        Draggable._dragging[element] = false
+                      }
+                    });
                   },
                   zindex: 1000,
                   revert: false,
-                  snap: false   // false, or xy or [x,y] or function(x,y){ return [x,y] }
+                  scroll: false,
-                }, arguments[1] || {});
+                  scrollSensitivity: 20,
+                  scrollSpeed: 15,
+                  snap: false,  // false, or xy or [x,y] or function(x,y){ return [x,y] }
+                  delay: 0
+                };
+                if(!arguments[1] || typeof arguments[1].endeffect == 'undefined')
+                  Object.extend(defaults, {
+                    starteffect: function(element) {
+                      element._opacity = Element.getOpacity(element);
+                      Draggable._dragging[element] = true;
+                      new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7});
+                    }
+                  });
+                var options = Object.extend(defaults, arguments[1] || {});
                 this.element = $(element);
                 if(options.handle && (typeof options.handle == 'string'))
-                  this.handle = Element.childrenWithClassName(this.element, options.handle)[0];
+                  this.handle = this.element.down('.'+options.handle, 0);
                 if(!this.handle) this.handle = $(options.handle);
                 if(!this.handle) this.handle = this.element;
+                if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
+                  options.scroll = $(options.scroll);
+                  this._isScrollChild = Element.childOf(this.element, options.scroll);
+                }
                 Element.makePositioned(this.element); // fix IE
                 this.delta    = this.currentDelta();
                 this.options  = options;
                 this.dragging = false;
                 this.eventMouseDown = this.initDrag.bindAsEventListener(this);
                 Event.observe(this.handle, "mousedown", this.eventMouseDown);
                 Draggables.register(this);
               },
               destroy: function() {
                 Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
                 Draggables.unregister(this);
               },
               currentDelta: function() {
                 return([
-                  parseInt(this.element.style.left || '0'),
+                  parseInt(Element.getStyle(this.element,'left') || '0'),
-                  parseInt(this.element.style.top || '0')]);
+                  parseInt(Element.getStyle(this.element,'top') || '0')]);
               },
               initDrag: function(event) {
+                if(typeof Draggable._dragging[this.element] != 'undefined' &&
+                  Draggable._dragging[this.element]) return;
                 if(Event.isLeftClick(event)) {
                   // abort on form elements, fixes a Firefox issue
                   var src = Event.element(event);
                   if(src.tagName && (
                     src.tagName=='INPUT' ||
                     src.tagName=='SELECT' ||
+                    src.tagName=='OPTION' ||
                     src.tagName=='BUTTON' ||
                     src.tagName=='TEXTAREA')) return;
-                  if(this.element._revert) {
-                    this.element._revert.cancel();
-                    this.element._revert = null;
                   var pointer = [Event.pointerX(event), Event.pointerY(event)];
                   var pos     = Position.cumulativeOffset(this.element);
                   this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });
                   Draggables.activate(this);
                   Event.stop(event);
                 }
               },
               startDrag: function(event) {
                 this.dragging = true;
                 if(this.options.zindex) {
                   this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
                   this.element.style.zIndex = this.options.zindex;
                 }
                 if(this.options.ghosting) {
                   this._clone = this.element.cloneNode(true);
                   Position.absolutize(this.element);
                   this.element.parentNode.insertBefore(this._clone, this.element);
                 }
+                if(this.options.scroll) {
+                  if (this.options.scroll == window) {
+                    var where = this._getWindowScroll(this.options.scroll);
+                    this.originalScrollLeft = where.left;
+                    this.originalScrollTop = where.top;
+                  } else {
+                    this.originalScrollLeft = this.options.scroll.scrollLeft;
+                    this.originalScrollTop = this.options.scroll.scrollTop;
+                  }
+                }
                 Draggables.notify('onStart', this, event);
                 if(this.options.starteffect) this.options.starteffect(this.element);
               },
               updateDrag: function(event, pointer) {
                 if(!this.dragging) this.startDrag(event);
                 Position.prepare();
                 Droppables.show(pointer, this.element);
                 Draggables.notify('onDrag', this, event);
                 this.draw(pointer);
                 if(this.options.change) this.options.change(this);
+                if(this.options.scroll) {
+                  this.stopScrolling();
+                  var p;
+                  if (this.options.scroll == window) {
+                    with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
+                  } else {
+                    p = Position.page(this.options.scroll);
+                    p[0] += this.options.scroll.scrollLeft + Position.deltaX;
+                    p[1] += this.options.scroll.scrollTop + Position.deltaY;
+                    p.push(p[0]+this.options.scroll.offsetWidth);
+                    p.push(p[1]+this.options.scroll.offsetHeight);
+                  }
+                  var speed = [0,0];
+                  if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
+                  if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
+                  if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
+                  if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
+                  this.startScrolling(speed);
+                }
                 // fix AppleWebKit rendering
                 if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
                 Event.stop(event);
               },
               finishDrag: function(event, success) {
                 this.dragging = false;
                 if(this.options.ghosting) {
                   Position.relativize(this.element);
                   Element.remove(this._clone);
                   this._clone = null;
                 }
                 if(success) Droppables.fire(event, this.element);
                 Draggables.notify('onEnd', this, event);
                 var revert = this.options.revert;
                 if(revert && typeof revert == 'function') revert = revert(this.element);
                 var d = this.currentDelta();
                 if(revert && this.options.reverteffect) {
                   this.options.reverteffect(this.element,
                     d[1]-this.delta[1], d[0]-this.delta[0]);
                 } else {
                   this.delta = d;
                 }
                 if(this.options.zindex)
                   this.element.style.zIndex = this.originalZ;
                 if(this.options.endeffect)
                   this.options.endeffect(this.element);
                 Draggables.deactivate(this);
                 Droppables.reset();
               },
               keyPress: function(event) {
-                if(!event.keyCode==Event.KEY_ESC) return;
+                if(event.keyCode!=Event.KEY_ESC) return;
                 this.finishDrag(event, false);
                 Event.stop(event);
               },
               endDrag: function(event) {
                 if(!this.dragging) return;
+                this.stopScrolling();
                 this.finishDrag(event, true);
                 Event.stop(event);
               },
               draw: function(point) {
                 var pos = Position.cumulativeOffset(this.element);
+                if(this.options.ghosting) {
+                  var r   = Position.realOffset(this.element);
+                  pos[0] += r[0] - Position.deltaX; pos[1] += r[1] - Position.deltaY;
+                }
                 var d = this.currentDelta();
                 pos[0] -= d[0]; pos[1] -= d[1];
-                var p = [0,1].map(function(i){ return (point[i]-pos[i]-this.offset[i]) }.bind(this));
+                if(this.options.scroll && (this.options.scroll != window && this._isScrollChild)) {
+                  pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
+                  pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
+                }
+                var p = [0,1].map(function(i){
+                  return (point[i]-pos[i]-this.offset[i])
+                }.bind(this));
                 if(this.options.snap) {
                   if(typeof this.options.snap == 'function') {
-                    p = this.options.snap(p[0],p[1]);
+                    p = this.options.snap(p[0],p[1],this);
                   } else {
                   if(this.options.snap instanceof Array) {
                     p = p.map( function(v, i) {
                       return Math.round(v/this.options.snap[i])*this.options.snap[i] }.bind(this))
                   } else {
                     p = p.map( function(v) {
                       return Math.round(v/this.options.snap)*this.options.snap }.bind(this))
                   }
                 }}
                 var style = this.element.style;
                 if((!this.options.constraint) || (this.options.constraint=='horizontal'))
                   style.left = p[0] + "px";
                 if((!this.options.constraint) || (this.options.constraint=='vertical'))
                   style.top  = p[1] + "px";
                 if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
+              },
+              stopScrolling: function() {
+                if(this.scrollInterval) {
+                  clearInterval(this.scrollInterval);
+                  this.scrollInterval = null;
+                  Draggables._lastScrollPointer = null;
+                }
+              },
+              startScrolling: function(speed) {
+                if(!(speed[0] || speed[1])) return;
+                this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
+                this.lastScrolled = new Date();
+                this.scrollInterval = setInterval(this.scroll.bind(this), 10);
+              },
+              scroll: function() {
+                var current = new Date();
+                var delta = current - this.lastScrolled;
+                this.lastScrolled = current;
+                if(this.options.scroll == window) {
+                  with (this._getWindowScroll(this.options.scroll)) {
+                    if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
+                      var d = delta / 1000;
+                      this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
+                    }
+                  }
+                } else {
+                  this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
+                  this.options.scroll.scrollTop  += this.scrollSpeed[1] * delta / 1000;
+                }
+                Position.prepare();
+                Droppables.show(Draggables._lastPointer, this.element);
+                Draggables.notify('onDrag', this);
+                if (this._isScrollChild) {
+                  Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);
+                  Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
+                  Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
+                  if (Draggables._lastScrollPointer[0] < 0)
+                    Draggables._lastScrollPointer[0] = 0;
+                  if (Draggables._lastScrollPointer[1] < 0)
+                    Draggables._lastScrollPointer[1] = 0;
+                  this.draw(Draggables._lastScrollPointer);
+                }
+                if(this.options.change) this.options.change(this);
+              },
+              _getWindowScroll: function(w) {
+                var T, L, W, H;
+                with (w.document) {
+                  if (w.document.documentElement && documentElement.scrollTop) {
+                    T = documentElement.scrollTop;
+                    L = documentElement.scrollLeft;
+                  } else if (w.document.body) {
+                    T = body.scrollTop;
+                    L = body.scrollLeft;
+                  }
+                  if (w.innerWidth) {
+                    W = w.innerWidth;
+                    H = w.innerHeight;
+                  } else if (w.document.documentElement && documentElement.clientWidth) {
+                    W = documentElement.clientWidth;
+                    H = documentElement.clientHeight;
+                  } else {
+                    W = body.offsetWidth;
+                    H = body.offsetHeight
+                  }
+                }
+                return { top: T, left: L, width: W, height: H };
               }
             }
             /*--------------------------------------------------------------------------*/
             var SortableObserver = Class.create();
             SortableObserver.prototype = {
               initialize: function(element, observer) {
                 this.element   = $(element);
                 this.observer  = observer;
                 this.lastValue = Sortable.serialize(this.element);
               },
               onStart: function() {
                 this.lastValue = Sortable.serialize(this.element);
               },
               onEnd: function() {
                 Sortable.unmark();
                 if(this.lastValue != Sortable.serialize(this.element))
                   this.observer(this.element)
               }
             }
             var Sortable = {
-              sortables: new Array(),
+              SERIALIZE_RULE: /^[^_\-](?:[A-Za-z0-9\-\_]*)[_](.*)$/,
-              options: function(element){
+              sortables: {},
-                element = $(element);
-                return this.sortables.detect(function(s) { return s.element == element });
+              _findRootElement: function(element) {
+                while (element.tagName != "BODY") {
+                  if(element.id && Sortable.sortables[element.id]) return element;
+                  element = element.parentNode;
+                }
+              },
+              options: function(element) {
+                element = Sortable._findRootElement($(element));
+                if(!element) return;
+                return Sortable.sortables[element.id];
               },
               destroy: function(element){
-                element = $(element);
+                var s = Sortable.options(element);
-                this.sortables.findAll(function(s) { return s.element == element }).each(function(s){
+                if(s) {
                   Draggables.removeObserver(s.element);
                   s.droppables.each(function(d){ Droppables.remove(d) });
                   s.draggables.invoke('destroy');
-                });
-                this.sortables = this.sortables.reject(function(s) { return s.element == element });
+                  delete Sortable.sortables[s.element.id];
+                }
               },
               create: function(element) {
                 element = $(element);
                 var options = Object.extend({
                   element:     element,
                   tag:         'li',       // assumes li children, override with tag: 'tagname'
                   dropOnEmpty: false,
-                  tree:        false,      // fixme: unimplemented
+                  tree:        false,
+                  treeTag:     'ul',
                   overlap:     'vertical', // one of 'vertical', 'horizontal'
                   constraint:  'vertical', // one of 'vertical', 'horizontal', false
                   containment: element,    // also takes array of elements (or id's); or false
                   handle:      false,      // or a CSS class
                   only:        false,
+                  delay:       0,
                   hoverclass:  null,
                   ghosting:    false,
-                  format:      null,
+                  scroll:      false,
+                  scrollSensitivity: 20,
+                  scrollSpeed: 15,
+                  format:      this.SERIALIZE_RULE,
                   onChange:    Prototype.emptyFunction,
                   onUpdate:    Prototype.emptyFunction
                 }, arguments[1] || {});
                 // clear any old sortable with same element
                 this.destroy(element);
                 // build options for the draggables
                 var options_for_draggable = {
                   revert:      true,
+                  scroll:      options.scroll,
+                  scrollSpeed: options.scrollSpeed,
+                  scrollSensitivity: options.scrollSensitivity,
+                  delay:       options.delay,
                   ghosting:    options.ghosting,
                   constraint:  options.constraint,
                   handle:      options.handle };
                 if(options.starteffect)
                   options_for_draggable.starteffect = options.starteffect;
                 if(options.reverteffect)
                   options_for_draggable.reverteffect = options.reverteffect;
                 else
                   if(options.ghosting) options_for_draggable.reverteffect = function(element) {
                     element.style.top  = 0;
                     element.style.left = 0;
                   };
                 if(options.endeffect)
                   options_for_draggable.endeffect = options.endeffect;
                 if(options.zindex)
                   options_for_draggable.zindex = options.zindex;
                 // build options for the droppables
                 var options_for_droppable = {
                   overlap:     options.overlap,
                   containment: options.containment,
+                  tree:        options.tree,
                   hoverclass:  options.hoverclass,
-                  onHover:     Sortable.onHover,
+                  onHover:     Sortable.onHover
-                  greedy:      !options.dropOnEmpty
+                var options_for_tree = {
+                  onHover:      Sortable.onEmptyHover,
+                  overlap:      options.overlap,
+                  containment:  options.containment,
+                  hoverclass:   options.hoverclass
                 }
                 // fix for gecko engine
                 Element.cleanWhitespace(element);
                 options.draggables = [];
                 options.droppables = [];
-                // make it so
                 // drop on empty handling
-                if(options.dropOnEmpty) {
+                if(options.dropOnEmpty || options.tree) {
-                  Droppables.add(element,
+                  Droppables.add(element, options_for_tree);
-                    {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false});
                   options.droppables.push(element);
                 }
                 (this.findElements(element, options) || []).each( function(e) {
                   // handles are per-draggable
                   var handle = options.handle ?
-                    Element.childrenWithClassName(e, options.handle)[0] : e;
+                    $(e).down('.'+options.handle,0) : e;
                   options.draggables.push(
                     new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
                   Droppables.add(e, options_for_droppable);
+                  if(options.tree) e.treeNode = element;
                   options.droppables.push(e);
                 });
+                if(options.tree) {
+                  (Sortable.findTreeElements(element, options) || []).each( function(e) {
+                    Droppables.add(e, options_for_tree);
+                    e.treeNode = element;
+                    options.droppables.push(e);
+                  });
+                }
                 // keep reference
-                this.sortables.push(options);
+                this.sortables[element.id] = options;
                 // for onupdate
                 Draggables.addObserver(new SortableObserver(element, options.onUpdate));
               },
               // return all suitable-for-sortable elements in a guaranteed order
               findElements: function(element, options) {
-                if(!element.hasChildNodes()) return null;
+                return Element.findChildren(
-                var elements = [];
+                  element, options.only, options.tree ? true : false, options.tag);
-                $A(element.childNodes).each( function(e) {
+              },
-                  if(e.tagName && e.tagName.toUpperCase()==options.tag.toUpperCase() &&
-                    (!options.only || (Element.hasClassName(e, options.only))))
+              findTreeElements: function(element, options) {
-                      elements.push(e);
+                return Element.findChildren(
-                  if(options.tree) {
+                  element, options.only, options.tree ? true : false, options.treeTag);
-                    var grandchildren = this.findElements(e, options);
-                    if(grandchildren) elements.push(grandchildren);
-                });
-                return (elements.length>0 ? elements.flatten() : null);
               },
               onHover: function(element, dropon, overlap) {
-                if(overlap>0.5) {
+                if(Element.isParent(dropon, element)) return;
+                if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
+                  return;
+                } else if(overlap>0.5) {
                   Sortable.mark(dropon, 'before');
                   if(dropon.previousSibling != element) {
                     var oldParentNode = element.parentNode;
                     element.style.visibility = "hidden"; // fix gecko rendering
                     dropon.parentNode.insertBefore(element, dropon);
                     if(dropon.parentNode!=oldParentNode)
                       Sortable.options(oldParentNode).onChange(element);
                     Sortable.options(dropon.parentNode).onChange(element);
                   }
                 } else {
                   Sortable.mark(dropon, 'after');
                   var nextElement = dropon.nextSibling || null;
                   if(nextElement != element) {
                     var oldParentNode = element.parentNode;
                     element.style.visibility = "hidden"; // fix gecko rendering
                     dropon.parentNode.insertBefore(element, nextElement);
                     if(dropon.parentNode!=oldParentNode)
                       Sortable.options(oldParentNode).onChange(element);
                     Sortable.options(dropon.parentNode).onChange(element);
                   }
                 }
               },
-              onEmptyHover: function(element, dropon) {
+              onEmptyHover: function(element, dropon, overlap) {
-                if(element.parentNode!=dropon) {
+                var oldParentNode = element.parentNode;
-                  var oldParentNode = element.parentNode;
+                var droponOptions = Sortable.options(dropon);
-                  dropon.appendChild(element);
+                if(!Element.isParent(dropon, element)) {
+                  var index;
+                  var children = Sortable.findElements(dropon, {tag: droponOptions.tag, only: droponOptions.only});
+                  var child = null;
+                  if(children) {
+                    var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
+                    for (index = 0; index < children.length; index += 1) {
+                      if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
+                        offset -= Element.offsetSize (children[index], droponOptions.overlap);
+                      } else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
+                        child = index + 1 < children.length ? children[index + 1] : null;
+                        break;
+                      } else {
+                        child = children[index];
+                        break;
+                      }
+                    }
+                  }
+                  dropon.insertBefore(element, child);
                   Sortable.options(oldParentNode).onChange(element);
-                  Sortable.options(dropon).onChange(element);
+                  droponOptions.onChange(element);
                 }
               },
               unmark: function() {
-                if(Sortable._marker) Element.hide(Sortable._marker);
+                if(Sortable._marker) Sortable._marker.hide();
               },
               mark: function(dropon, position) {
                 // mark on ghosting only
                 var sortable = Sortable.options(dropon.parentNode);
                 if(sortable && !sortable.ghosting) return;
                 if(!Sortable._marker) {
-                  Sortable._marker = $('dropmarker') || document.createElement('DIV');
+                  Sortable._marker =
-                  Element.hide(Sortable._marker);
+                    ($('dropmarker') || Element.extend(document.createElement('DIV'))).
-                  Element.addClassName(Sortable._marker, 'dropmarker');
+                      hide().addClassName('dropmarker').setStyle({position:'absolute'});
-                  Sortable._marker.style.position = 'absolute';
                   document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
                 }
                 var offsets = Position.cumulativeOffset(dropon);
-                Sortable._marker.style.left = offsets[0] + 'px';
+                Sortable._marker.setStyle({left: offsets[0]+'px', top: offsets[1] + 'px'});
-                Sortable._marker.style.top = offsets[1] + 'px';
                 if(position=='after')
                   if(sortable.overlap == 'horizontal')
-                    Sortable._marker.style.left = (offsets[0]+dropon.clientWidth) + 'px';
+                    Sortable._marker.setStyle({left: (offsets[0]+dropon.clientWidth) + 'px'});
                   else
-                    Sortable._marker.style.top = (offsets[1]+dropon.clientHeight) + 'px';
+                    Sortable._marker.setStyle({top: (offsets[1]+dropon.clientHeight) + 'px'});
-                Element.show(Sortable._marker);
+                Sortable._marker.show();
               },
+              _tree: function(element, options, parent) {
+                var children = Sortable.findElements(element, options) || [];
+                for (var i = 0; i < children.length; ++i) {
+                  var match = children[i].id.match(options.format);
-              serialize: function(element) {
+                  if (!match) continue;
+                  var child = {
+                    id: encodeURIComponent(match ? match[1] : null),
+                    element: element,
+                    parent: parent,
+                    children: [],
+                    position: parent.children.length,
+                    container: $(children[i]).down(options.treeTag)
+                  }
+                  /* Get the element containing the children and recurse over it */
+                  if (child.container)
+                    this._tree(child.container, options, child)
+                  parent.children.push (child);
+                }
+                return parent;
+              },
+              tree: function(element) {
                 element = $(element);
                 var sortableOptions = this.options(element);
                 var options = Object.extend({
-                  tag:  sortableOptions.tag,
+                  tag: sortableOptions.tag,
+                  treeTag: sortableOptions.treeTag,
                   only: sortableOptions.only,
                   name: element.id,
-                  format: sortableOptions.format || /^[^_]*_(.*)$/
+                  format: sortableOptions.format
                 }, arguments[1] || {});
+                var root = {
+                  id: null,
+                  parent: null,
+                  children: [],
+                  container: element,
+                  position: 0
+                }
+                return Sortable._tree(element, options, root);
+              },
+              /* Construct a [i] index for a particular node */
+              _constructIndex: function(node) {
+                var index = '';
+                do {
+                  if (node.id) index = '[' + node.position + ']' + index;
+                } while ((node = node.parent) != null);
+                return index;
+              },
+              sequence: function(element) {
+                element = $(element);
+                var options = Object.extend(this.options(element), arguments[1] || {});
                 return $(this.findElements(element, options) || []).map( function(item) {
-                  return (encodeURIComponent(options.name) + "[]=" +
+                  return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
-                          encodeURIComponent(item.id.match(options.format) ? item.id.match(options.format)[1] : ''));
+                });
-                }).join("&");
+              },
+              setSequence: function(element, new_sequence) {
+                element = $(element);
+                var options = Object.extend(this.options(element), arguments[2] || {});
+                var nodeMap = {};
+                this.findElements(element, options).each( function(n) {
+                    if (n.id.match(options.format))
+                        nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
+                    n.parentNode.removeChild(n);
+                });
+                new_sequence.each(function(ident) {
+                  var n = nodeMap[ident];
+                  if (n) {
+                    n[1].appendChild(n[0]);
+                    delete nodeMap[ident];
+                  }
+                });
+              },
+              serialize: function(element) {
+                element = $(element);
+                var options = Object.extend(Sortable.options(element), arguments[1] || {});
+                var name = encodeURIComponent(
+                  (arguments[1] && arguments[1].name) ? arguments[1].name : element.id);
+                if (options.tree) {
+                  return Sortable.tree(element, arguments[1]).children.map( function (item) {
+                    return [name + Sortable._constructIndex(item) + "[id]=" +
+                            encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
+                  }).flatten().join('&');
+                } else {
+                  return Sortable.sequence(element, arguments[1]).map( function(item) {
+                    return name + "[]=" + encodeURIComponent(item);
+                  }).join('&');
+                }
               }
-            }
  No newline at end of file
+            // Returns true if child is contained within element
+            Element.isParent = function(child, element) {
+              if (!child.parentNode || child == element) return false;
+              if (child.parentNode == element) return true;
+              return Element.isParent(child.parentNode, element);
+            }
+            Element.findChildren = function(element, only, recursive, tagName) {
+              if(!element.hasChildNodes()) return null;
+              tagName = tagName.toUpperCase();
+              if(only) only = [only].flatten();
+              var elements = [];
+              $A(element.childNodes).each( function(e) {
+                if(e.tagName && e.tagName.toUpperCase()==tagName &&
+                  (!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
+                    elements.push(e);
+                if(recursive) {
+                  var grandchildren = Element.findChildren(e, only, recursive, tagName);
+                  if(grandchildren) elements.push(grandchildren);
+                }
+              });
+              return (elements.length>0 ? elements.flatten() : []);
+            }
+            Element.offsetSize = function (element, type) {
+              return element['offset' + ((type=='vertical' || type=='height') ? 'Height' : 'Width')];
+            }

public/javascripts/effects.js +517 -283

-            // Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
+            // Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
             // Contributors:
             //  Justin Palmer (http://encytemedia.com/)
             //  Mark Pilgrim (http://diveintomark.org/)
             //  Martin Bialasinki
             //
-            // See scriptaculous.js for full license.
+            // script.aculo.us is freely distributable under the terms of an MIT-style license.
+            // For details, see the script.aculo.us web site: http://script.aculo.us/
-            /* ------------- element ext -------------- */
             // converts rgb() and #xxx to #xxxxxx format,
             // returns self (or first argument) if not convertable
             String.prototype.parseColor = function() {
               var color = '#';
               if(this.slice(0,4) == 'rgb(') {
                 var cols = this.slice(4,this.length-1).split(',');
                 var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);
               } else {
                 if(this.slice(0,1) == '#') {
                   if(this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();
                   if(this.length==7) color = this.toLowerCase();
                 }
               }
               return(color.length==7 ? color : (arguments[0] || this));
+            }
-            Element.collectTextNodesIgnoreClass = function(element, ignoreclass) {
+            /*--------------------------------------------------------------------------*/
-              var children = $(element).childNodes;
-              var text     = '';
+            Element.collectTextNodes = function(element) {
-              var classtest = new RegExp('^([^ ]+ )*' + ignoreclass+ '( [^ ]+)*$','i');
+              return $A($(element).childNodes).collect( function(node) {
+                return (node.nodeType==3 ? node.nodeValue :
-              for (var i = 0; i < children.length; i++) {
+                  (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
-                if(children[i].nodeType==3) {
+              }).flatten().join('');
-                  text+=children[i].nodeValue;
-                } else {
-                  if((!children[i].className.match(classtest)) && children[i].hasChildNodes())
-                    text += Element.collectTextNodesIgnoreClass(children[i], ignoreclass);
-              return text;
             }
-            Element.setStyle = function(element, style) {
+            Element.collectTextNodesIgnoreClass = function(element, className) {
-              element = $(element);
+              return $A($(element).childNodes).collect( function(node) {
-              for(k in style) element.style[k.camelize()] = style[k];
+                return (node.nodeType==3 ? node.nodeValue :
+                  ((node.hasChildNodes() && !Element.hasClassName(node,className)) ?
+                    Element.collectTextNodesIgnoreClass(node, className) : ''));
+              }).flatten().join('');
             }
             Element.setContentZoom = function(element, percent) {
-              Element.setStyle(element, {fontSize: (percent/100) + 'em'});
+              element = $(element);
-              if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
+              element.setStyle({fontSize: (percent/100) + 'em'});
+              if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
+              return element;
             }
             Element.getOpacity = function(element){
+              element = $(element);
               var opacity;
-              if (opacity = Element.getStyle(element, 'opacity'))
+              if (opacity = element.getStyle('opacity'))
                 return parseFloat(opacity);
-              if (opacity = (Element.getStyle(element, 'filter') || '').match(/alpha\(opacity=(.*)\)/))
+              if (opacity = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
                 if(opacity[1]) return parseFloat(opacity[1]) / 100;
               return 1.0;
             }
             Element.setOpacity = function(element, value){
               element= $(element);
               if (value == 1){
-                Element.setStyle(element, { opacity:
+                element.setStyle({ opacity:
                   (/Gecko/.test(navigator.userAgent) && !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ?
-.999999 : null });
+.999999 : 1.0 });
-                if(/MSIE/.test(navigator.userAgent))
+                if(/MSIE/.test(navigator.userAgent) && !window.opera)
-                  Element.setStyle(element, {filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'')});
+                  element.setStyle({filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'')});
               } else {
                 if(value < 0.00001) value = 0;
-                Element.setStyle(element, {opacity: value});
+                element.setStyle({opacity: value});
-                if(/MSIE/.test(navigator.userAgent))
+                if(/MSIE/.test(navigator.userAgent) && !window.opera)
-                 Element.setStyle(element,
+                  element.setStyle(
-                   { filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'') +
+                    { filter: element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'') +
-                             'alpha(opacity='+value*100+')' });
+                        'alpha(opacity='+value*100+')' });
+              }
+              return element;
             }
             Element.getInlineOpacity = function(element){
               return $(element).style.opacity || '';
             }
-            Element.childrenWithClassName = function(element, className) {
+            Element.forceRerendering = function(element) {
-              return $A($(element).getElementsByTagName('*')).select(
+              try {
-                function(c) { return Element.hasClassName(c, className) });
+                element = $(element);
+                var n = document.createTextNode(' ');
+                element.appendChild(n);
+                element.removeChild(n);
+              } catch(e) { }
+            };
+            /*--------------------------------------------------------------------------*/
             Array.prototype.call = function() {
               var args = arguments;
               this.each(function(f){ f.apply(this, args) });
             }
             /*--------------------------------------------------------------------------*/
             var Effect = {
+              _elementDoesNotExistError: {
+                name: 'ElementDoesNotExistError',
+                message: 'The specified DOM element does not exist, but is required for this effect to operate'
+              },
               tagifyText: function(element) {
+                if(typeof Builder == 'undefined')
+                  throw("Effect.tagifyText requires including script.aculo.us' builder.js library");
                 var tagifyStyle = 'position:relative';
-                if(/MSIE/.test(navigator.userAgent)) tagifyStyle += ';zoom:1';
+                if(/MSIE/.test(navigator.userAgent) && !window.opera) tagifyStyle += ';zoom:1';
                 element = $(element);
                 $A(element.childNodes).each( function(child) {
                   if(child.nodeType==3) {
                     child.nodeValue.toArray().each( function(character) {
                       element.insertBefore(
                         Builder.node('span',{style: tagifyStyle},
                           character == ' ' ? String.fromCharCode(160) : character),
                           child);
                     });
                     Element.remove(child);
                   }
                 });
               },
               multiple: function(element, effect) {
                 var elements;
                 if(((typeof element == 'object') ||
                     (typeof element == 'function')) &&
                    (element.length))
                   elements = element;
                 else
                   elements = $(element).childNodes;
                 var options = Object.extend({
                   speed: 0.1,
                   delay: 0.0
                 }, arguments[2] || {});
                 var masterDelay = options.delay;
                 $A(elements).each( function(element, index) {
                   new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
                 });
+              },
+              PAIRS: {
+                'slide':  ['SlideDown','SlideUp'],
+                'blind':  ['BlindDown','BlindUp'],
+                'appear': ['Appear','Fade']
+              },
+              toggle: function(element, effect) {
+                element = $(element);
+                effect = (effect || 'appear').toLowerCase();
+                var options = Object.extend({
+                  queue: { position:'end', scope:(element.id || 'global'), limit: 1 }
+                }, arguments[2] || {});
+                Effect[element.visible() ?
+                  Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
               }
             };
             var Effect2 = Effect; // deprecated
             /* ------------- transitions ------------- */
-            Effect.Transitions = {}
+            Effect.Transitions = {
+              linear: Prototype.K,
-            Effect.Transitions.linear = function(pos) {
+              sinoidal: function(pos) {
-              return pos;
+                return (-Math.cos(pos*Math.PI)/2) + 0.5;
+              },
-            Effect.Transitions.sinoidal = function(pos) {
+              reverse: function(pos) {
-              return (-Math.cos(pos*Math.PI)/2) + 0.5;
+                return 1-pos;
+              },
-            Effect.Transitions.reverse  = function(pos) {
+              flicker: function(pos) {
-              return 1-pos;
+                return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
+              },
-            Effect.Transitions.flicker = function(pos) {
+              wobble: function(pos) {
-              return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
+                return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
+              },
-            Effect.Transitions.wobble = function(pos) {
+              pulse: function(pos, pulses) {
-              return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
+                pulses = pulses || 5;
+                return (
-            Effect.Transitions.pulse = function(pos) {
+                  Math.round((pos % (1/pulses)) * pulses) == 0 ?
-              return (Math.floor(pos*10) % 2 == 0 ?
+                        ((pos * pulses * 2) - Math.floor(pos * pulses * 2)) :
-                (pos*10-Math.floor(pos*10)) : 1-(pos*10-Math.floor(pos*10)));
+- ((pos * pulses * 2) - Math.floor(pos * pulses * 2))
+                  );
-            Effect.Transitions.none = function(pos) {
+              },
-              return 0;
+              none: function(pos) {
+                return 0;
-            Effect.Transitions.full = function(pos) {
+              },
-              return 1;
+              full: function(pos) {
+                return 1;
+              }
+            };
             /* ------------- core effects ------------- */
-            Effect.Queue = {
+            Effect.ScopedQueue = Class.create();
-              effects:  [],
+            Object.extend(Object.extend(Effect.ScopedQueue.prototype, Enumerable), {
+              initialize: function() {
+                this.effects  = [];
+                this.interval = null;
+              },
               _each: function(iterator) {
                 this.effects._each(iterator);
               },
-              interval: null,
               add: function(effect) {
                 var timestamp = new Date().getTime();
-                switch(effect.options.queue) {
+                var position = (typeof effect.options.queue == 'string') ?
+                  effect.options.queue : effect.options.queue.position;
+                switch(position) {
                   case 'front':
                     // move unstarted effects after this effect
                     this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
                         e.startOn  += effect.finishOn;
                         e.finishOn += effect.finishOn;
                       });
                     break;
+                  case 'with-last':
+                    timestamp = this.effects.pluck('startOn').max() || timestamp;
+                    break;
                   case 'end':
                     // start effect after last queued effect has finished
                     timestamp = this.effects.pluck('finishOn').max() || timestamp;
                     break;
                 }
                 effect.startOn  += timestamp;
                 effect.finishOn += timestamp;
-                this.effects.push(effect);
+                if(!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
+                  this.effects.push(effect);
                 if(!this.interval)
                   this.interval = setInterval(this.loop.bind(this), 40);
               },
               remove: function(effect) {
                 this.effects = this.effects.reject(function(e) { return e==effect });
                 if(this.effects.length == 0) {
                   clearInterval(this.interval);
                   this.interval = null;
                 }
               },
               loop: function() {
                 var timePos = new Date().getTime();
                 this.effects.invoke('loop', timePos);
               }
+            });
+            Effect.Queues = {
+              instances: $H(),
+              get: function(queueName) {
+                if(typeof queueName != 'string') return queueName;
+                if(!this.instances[queueName])
+                  this.instances[queueName] = new Effect.ScopedQueue();
+                return this.instances[queueName];
+              }
+            }
+            Effect.Queue = Effect.Queues.get('global');
+            Effect.DefaultOptions = {
+              transition: Effect.Transitions.sinoidal,
+              duration:   1.0,   // seconds
+              fps:        25.0,  // max. 25fps due to Effect.Queue implementation
+              sync:       false, // true for combining
+              from:       0.0,
+              to:         1.0,
+              delay:      0.0,
+              queue:      'parallel'
             }
-            Object.extend(Effect.Queue, Enumerable);
             Effect.Base = function() {};
             Effect.Base.prototype = {
               position: null,
-              setOptions: function(options) {
-                this.options = Object.extend({
-                  transition: Effect.Transitions.sinoidal,
-                  duration:   1.0,   // seconds
-                  fps:        25.0,  // max. 25fps due to Effect.Queue implementation
-                  sync:       false, // true for combining
-                  from:       0.0,
-                  to:         1.0,
-                  delay:      0.0,
-                  queue:      'parallel'
-                }, options || {});
-              },
               start: function(options) {
-                this.setOptions(options || {});
+                this.options      = Object.extend(Object.extend({},Effect.DefaultOptions), options || {});
                 this.currentFrame = 0;
                 this.state        = 'idle';
                 this.startOn      = this.options.delay*1000;
                 this.finishOn     = this.startOn + (this.options.duration*1000);
                 this.event('beforeStart');
-                if(!this.options.sync) Effect.Queue.add(this);
+                if(!this.options.sync)
+                  Effect.Queues.get(typeof this.options.queue == 'string' ?
+                    'global' : this.options.queue.scope).add(this);
               },
               loop: function(timePos) {
                 if(timePos >= this.startOn) {
                   if(timePos >= this.finishOn) {
                     this.render(1.0);
                     this.cancel();
                     this.event('beforeFinish');
                     if(this.finish) this.finish();
                     this.event('afterFinish');
                     return;
                   }
                   var pos   = (timePos - this.startOn) / (this.finishOn - this.startOn);
                   var frame = Math.round(pos * this.options.fps * this.options.duration);
                   if(frame > this.currentFrame) {
                     this.render(pos);
                     this.currentFrame = frame;
                   }
                 }
               },
               render: function(pos) {
                 if(this.state == 'idle') {
                   this.state = 'running';
                   this.event('beforeSetup');
                   if(this.setup) this.setup();
                   this.event('afterSetup');
                 }
                 if(this.state == 'running') {
                   if(this.options.transition) pos = this.options.transition(pos);
                   pos *= (this.options.to-this.options.from);
                   pos += this.options.from;
                   this.position = pos;
                   this.event('beforeUpdate');
                   if(this.update) this.update(pos);
                   this.event('afterUpdate');
                 }
               },
               cancel: function() {
-                if(!this.options.sync) Effect.Queue.remove(this);
+                if(!this.options.sync)
+                  Effect.Queues.get(typeof this.options.queue == 'string' ?
+                    'global' : this.options.queue.scope).remove(this);
                 this.state = 'finished';
               },
               event: function(eventName) {
                 if(this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
                 if(this.options[eventName]) this.options[eventName](this);
               },
               inspect: function() {
                 return '#<Effect:' + $H(this).inspect() + ',options:' + $H(this.options).inspect() + '>';
               }
             }
             Effect.Parallel = Class.create();
             Object.extend(Object.extend(Effect.Parallel.prototype, Effect.Base.prototype), {
               initialize: function(effects) {
                 this.effects = effects || [];
                 this.start(arguments[1]);
               },
               update: function(position) {
                 this.effects.invoke('render', position);
               },
               finish: function(position) {
                 this.effects.each( function(effect) {
                   effect.render(1.0);
                   effect.cancel();
                   effect.event('beforeFinish');
                   if(effect.finish) effect.finish(position);
                   effect.event('afterFinish');
                 });
               }
             });
+            Effect.Event = Class.create();
+            Object.extend(Object.extend(Effect.Event.prototype, Effect.Base.prototype), {
+              initialize: function() {
+                var options = Object.extend({
+                  duration: 0
+                }, arguments[0] || {});
+                this.start(options);
+              },
+              update: Prototype.emptyFunction
+            });
             Effect.Opacity = Class.create();
             Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype), {
               initialize: function(element) {
                 this.element = $(element);
+                if(!this.element) throw(Effect._elementDoesNotExistError);
                 // make this work on IE on elements without 'layout'
-                if(/MSIE/.test(navigator.userAgent) && (!this.element.hasLayout))
+                if(/MSIE/.test(navigator.userAgent) && !window.opera && (!this.element.currentStyle.hasLayout))
-                  Element.setStyle(this.element, {zoom: 1});
+                  this.element.setStyle({zoom: 1});
                 var options = Object.extend({
-                  from: Element.getOpacity(this.element) || 0.0,
+                  from: this.element.getOpacity() || 0.0,
                   to:   1.0
                 }, arguments[1] || {});
                 this.start(options);
               },
               update: function(position) {
-                Element.setOpacity(this.element, position);
+                this.element.setOpacity(position);
               }
             });
-            Effect.MoveBy = Class.create();
+            Effect.Move = Class.create();
-            Object.extend(Object.extend(Effect.MoveBy.prototype, Effect.Base.prototype), {
+            Object.extend(Object.extend(Effect.Move.prototype, Effect.Base.prototype), {
-              initialize: function(element, toTop, toLeft) {
+              initialize: function(element) {
-                this.element      = $(element);
+                this.element = $(element);
-                this.toTop        = toTop;
+                if(!this.element) throw(Effect._elementDoesNotExistError);
-                this.toLeft       = toLeft;
+                var options = Object.extend({
-                this.start(arguments[3]);
+                  x:    0,
+                  y:    0,
+                  mode: 'relative'
+                }, arguments[1] || {});
+                this.start(options);
               },
               setup: function() {
                 // Bug in Opera: Opera returns the "real" position of a static element or
                 // relative element that does not have top/left explicitly set.
                 // ==> Always set top and left for position relative elements in your stylesheets
                 // (to 0 if you do not need them)
-                Element.makePositioned(this.element);
+                this.element.makePositioned();
-                this.originalTop  = parseFloat(Element.getStyle(this.element,'top')  || '0');
+                this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
-                this.originalLeft = parseFloat(Element.getStyle(this.element,'left') || '0');
+                this.originalTop  = parseFloat(this.element.getStyle('top')  || '0');
+                if(this.options.mode == 'absolute') {
+                  // absolute movement, so we need to calc deltaX and deltaY
+                  this.options.x = this.options.x - this.originalLeft;
+                  this.options.y = this.options.y - this.originalTop;
+                }
               },
               update: function(position) {
-                Element.setStyle(this.element, {
+                this.element.setStyle({
-                  top:  this.toTop  * position + this.originalTop + 'px',
+                  left: Math.round(this.options.x  * position + this.originalLeft) + 'px',
-                  left: this.toLeft * position + this.originalLeft + 'px'
+                  top:  Math.round(this.options.y  * position + this.originalTop)  + 'px'
                 });
               }
             });
+            // for backwards compatibility
+            Effect.MoveBy = function(element, toTop, toLeft) {
+              return new Effect.Move(element,
+                Object.extend({ x: toLeft, y: toTop }, arguments[3] || {}));
+            };
             Effect.Scale = Class.create();
             Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
               initialize: function(element, percent) {
-                this.element = $(element)
+                this.element = $(element);
+                if(!this.element) throw(Effect._elementDoesNotExistError);
                 var options = Object.extend({
                   scaleX: true,
                   scaleY: true,
                   scaleContent: true,
                   scaleFromCenter: false,
                   scaleMode: 'box',        // 'box' or 'contents' or {} with provided values
                   scaleFrom: 100.0,
                   scaleTo:   percent
                 }, arguments[2] || {});
                 this.start(options);
               },
               setup: function() {
                 this.restoreAfterFinish = this.options.restoreAfterFinish || false;
-                this.elementPositioning = Element.getStyle(this.element,'position');
+                this.elementPositioning = this.element.getStyle('position');
                 this.originalStyle = {};
                 ['top','left','width','height','fontSize'].each( function(k) {
                   this.originalStyle[k] = this.element.style[k];
                 }.bind(this));
                 this.originalTop  = this.element.offsetTop;
                 this.originalLeft = this.element.offsetLeft;
-                var fontSize = Element.getStyle(this.element,'font-size') || '100%';
+                var fontSize = this.element.getStyle('font-size') || '100%';
-                ['em','px','%'].each( function(fontSizeType) {
+                ['em','px','%','pt'].each( function(fontSizeType) {
                   if(fontSize.indexOf(fontSizeType)>0) {
                     this.fontSize     = parseFloat(fontSize);
                     this.fontSizeType = fontSizeType;
                   }
                 }.bind(this));
                 this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
                 this.dims = null;
                 if(this.options.scaleMode=='box')
                   this.dims = [this.element.offsetHeight, this.element.offsetWidth];
                 if(/^content/.test(this.options.scaleMode))
                   this.dims = [this.element.scrollHeight, this.element.scrollWidth];
                 if(!this.dims)
                   this.dims = [this.options.scaleMode.originalHeight,
                                this.options.scaleMode.originalWidth];
               },
               update: function(position) {
                 var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
                 if(this.options.scaleContent && this.fontSize)
-                  Element.setStyle(this.element, {fontSize: this.fontSize * currentScale + this.fontSizeType });
+                  this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
                 this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
               },
               finish: function(position) {
-                if (this.restoreAfterFinish) Element.setStyle(this.element, this.originalStyle);
+                if(this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
               },
               setDimensions: function(height, width) {
                 var d = {};
-                if(this.options.scaleX) d.width = width + 'px';
+                if(this.options.scaleX) d.width = Math.round(width) + 'px';
-                if(this.options.scaleY) d.height = height + 'px';
+                if(this.options.scaleY) d.height = Math.round(height) + 'px';
                 if(this.options.scaleFromCenter) {
                   var topd  = (height - this.dims[0])/2;
                   var leftd = (width  - this.dims[1])/2;
                   if(this.elementPositioning == 'absolute') {
                     if(this.options.scaleY) d.top = this.originalTop-topd + 'px';
                     if(this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
                   } else {
                     if(this.options.scaleY) d.top = -topd + 'px';
                     if(this.options.scaleX) d.left = -leftd + 'px';
                   }
                 }
-                Element.setStyle(this.element, d);
+                this.element.setStyle(d);
               }
             });
             Effect.Highlight = Class.create();
             Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype), {
               initialize: function(element) {
                 this.element = $(element);
+                if(!this.element) throw(Effect._elementDoesNotExistError);
                 var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || {});
                 this.start(options);
               },
               setup: function() {
                 // Prevent executing on elements not in the layout flow
-                if(Element.getStyle(this.element, 'display')=='none') { this.cancel(); return; }
+                if(this.element.getStyle('display')=='none') { this.cancel(); return; }
                 // Disable background image during the effect
                 this.oldStyle = {
-                  backgroundImage: Element.getStyle(this.element, 'background-image') };
+                  backgroundImage: this.element.getStyle('background-image') };
-                Element.setStyle(this.element, {backgroundImage: 'none'});
+                this.element.setStyle({backgroundImage: 'none'});
                 if(!this.options.endcolor)
-                  this.options.endcolor = Element.getStyle(this.element, 'background-color').parseColor('#ffffff');
+                  this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
                 if(!this.options.restorecolor)
-                  this.options.restorecolor = Element.getStyle(this.element, 'background-color');
+                  this.options.restorecolor = this.element.getStyle('background-color');
                 // init color calculations
                 this._base  = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
                 this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
               },
               update: function(position) {
-                Element.setStyle(this.element,{backgroundColor: $R(0,2).inject('#',function(m,v,i){
+                this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
                   return m+(Math.round(this._base[i]+(this._delta[i]*position)).toColorPart()); }.bind(this)) });
               },
               finish: function() {
-                Element.setStyle(this.element, Object.extend(this.oldStyle, {
+                this.element.setStyle(Object.extend(this.oldStyle, {
                   backgroundColor: this.options.restorecolor
                 }));
               }
             });
             Effect.ScrollTo = Class.create();
             Object.extend(Object.extend(Effect.ScrollTo.prototype, Effect.Base.prototype), {
               initialize: function(element) {
                 this.element = $(element);
                 this.start(arguments[1] || {});
               },
               setup: function() {
                 Position.prepare();
                 var offsets = Position.cumulativeOffset(this.element);
                 if(this.options.offset) offsets[1] += this.options.offset;
                 var max = window.innerHeight ?
                   window.height - window.innerHeight :
                   document.body.scrollHeight -
                     (document.documentElement.clientHeight ?
                       document.documentElement.clientHeight : document.body.clientHeight);
                 this.scrollStart = Position.deltaY;
                 this.delta = (offsets[1] > max ? max : offsets[1]) - this.scrollStart;
               },
               update: function(position) {
                 Position.prepare();
                 window.scrollTo(Position.deltaX,
                   this.scrollStart + (position*this.delta));
               }
             });
             /* ------------- combination effects ------------- */
             Effect.Fade = function(element) {
-              var oldOpacity = Element.getInlineOpacity(element);
+              element = $(element);
+              var oldOpacity = element.getInlineOpacity();
               var options = Object.extend({
-              from: Element.getOpacity(element) || 1.0,
+              from: element.getOpacity() || 1.0,
               to:   0.0,
-              afterFinishInternal: function(effect) { with(Element) {
+              afterFinishInternal: function(effect) {
                 if(effect.options.to!=0) return;
-                hide(effect.element);
+                effect.element.hide().setStyle({opacity: oldOpacity});
-                setStyle(effect.element, {opacity: oldOpacity}); }}
+              }}, arguments[1] || {});
-              }, arguments[1] || {});
               return new Effect.Opacity(element,options);
             }
             Effect.Appear = function(element) {
+              element = $(element);
               var options = Object.extend({
-              from: (Element.getStyle(element, 'display') == 'none' ? 0.0 : Element.getOpacity(element) || 0.0),
+              from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
               to:   1.0,
-              beforeSetup: function(effect) { with(Element) {
+              // force Safari to render floated elements properly
-                setOpacity(effect.element, effect.options.from);
+              afterFinishInternal: function(effect) {
-                show(effect.element); }}
+                effect.element.forceRerendering();
-              }, arguments[1] || {});
+              },
+              beforeSetup: function(effect) {
+                effect.element.setOpacity(effect.options.from).show();
+              }}, arguments[1] || {});
               return new Effect.Opacity(element,options);
             }
             Effect.Puff = function(element) {
               element = $(element);
-              var oldStyle = { opacity: Element.getInlineOpacity(element), position: Element.getStyle(element, 'position') };
+              var oldStyle = {
+                opacity: element.getInlineOpacity(),
+                position: element.getStyle('position'),
+                top:  element.style.top,
+                left: element.style.left,
+                width: element.style.width,
+                height: element.style.height
+              };
               return new Effect.Parallel(
                [ new Effect.Scale(element, 200,
                   { sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }),
                  new Effect.Opacity(element, { sync: true, to: 0.0 } ) ],
                  Object.extend({ duration: 1.0,
-                  beforeSetupInternal: function(effect) { with(Element) {
+                  beforeSetupInternal: function(effect) {
-                    setStyle(effect.effects[0].element, {position: 'absolute'}); }},
+                    Position.absolutize(effect.effects[0].element)
-                  afterFinishInternal: function(effect) { with(Element) {
+                  },
-                     hide(effect.effects[0].element);
+                  afterFinishInternal: function(effect) {
-                     setStyle(effect.effects[0].element, oldStyle); }}
+                     effect.effects[0].element.hide().setStyle(oldStyle); }
                  }, arguments[1] || {})
                );
             }
             Effect.BlindUp = function(element) {
               element = $(element);
-              Element.makeClipping(element);
+              element.makeClipping();
               return new Effect.Scale(element, 0,
                 Object.extend({ scaleContent: false,
                   scaleX: false,
                   restoreAfterFinish: true,
-                  afterFinishInternal: function(effect) { with(Element) {
+                  afterFinishInternal: function(effect) {
-                    [hide, undoClipping].call(effect.element); }}
+                    effect.element.hide().undoClipping();
+                  }
                 }, arguments[1] || {})
               );
             }
             Effect.BlindDown = function(element) {
               element = $(element);
-              var oldHeight = Element.getStyle(element, 'height');
+              var elementDimensions = element.getDimensions();
-              var elementDimensions = Element.getDimensions(element);
+              return new Effect.Scale(element, 100, Object.extend({
-              return new Effect.Scale(element, 100,
+                scaleContent: false,
-                Object.extend({ scaleContent: false,
+                scaleX: false,
-                  scaleX: false,
+                scaleFrom: 0,
-                  scaleFrom: 0,
+                scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
-                  scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
+                restoreAfterFinish: true,
-                  restoreAfterFinish: true,
+                afterSetup: function(effect) {
-                  afterSetup: function(effect) { with(Element) {
+                  effect.element.makeClipping().setStyle({height: '0px'}).show();
-                    makeClipping(effect.element);
+                },
-                    setStyle(effect.element, {height: '0px'});
+                afterFinishInternal: function(effect) {
-                    show(effect.element);
+                  effect.element.undoClipping();
-                  }},
-                  afterFinishInternal: function(effect) { with(Element) {
+              }, arguments[1] || {}));
-                    undoClipping(effect.element);
-                    setStyle(effect.element, {height: oldHeight});
-                  }}
-                }, arguments[1] || {})
-              );
             }
             Effect.SwitchOff = function(element) {
               element = $(element);
-              var oldOpacity = Element.getInlineOpacity(element);
+              var oldOpacity = element.getInlineOpacity();
-              return new Effect.Appear(element, {
+              return new Effect.Appear(element, Object.extend({
                 duration: 0.4,
                 from: 0,
                 transition: Effect.Transitions.flicker,
                 afterFinishInternal: function(effect) {
                   new Effect.Scale(effect.element, 1, {
                     duration: 0.3, scaleFromCenter: true,
                     scaleX: false, scaleContent: false, restoreAfterFinish: true,
-                    beforeSetup: function(effect) { with(Element) {
+                    beforeSetup: function(effect) {
-                      [makePositioned,makeClipping].call(effect.element);
+                      effect.element.makePositioned().makeClipping();
-                    }},
+                    },
-                    afterFinishInternal: function(effect) { with(Element) {
+                    afterFinishInternal: function(effect) {
-                      [hide,undoClipping,undoPositioned].call(effect.element);
+                      effect.element.hide().undoClipping().undoPositioned().setStyle({opacity: oldOpacity});
-                      setStyle(effect.element, {opacity: oldOpacity});
-                    }}
                   })
                 }
-              });
+              }, arguments[1] || {}));
             }
             Effect.DropOut = function(element) {
               element = $(element);
               var oldStyle = {
-                top: Element.getStyle(element, 'top'),
+                top: element.getStyle('top'),
-                left: Element.getStyle(element, 'left'),
+                left: element.getStyle('left'),
-                opacity: Element.getInlineOpacity(element) };
+                opacity: element.getInlineOpacity() };
               return new Effect.Parallel(
-                [ new Effect.MoveBy(element, 100, 0, { sync: true }),
+                [ new Effect.Move(element, {x: 0, y: 100, sync: true }),
                   new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
                 Object.extend(
                   { duration: 0.5,
-                    beforeSetup: function(effect) { with(Element) {
+                    beforeSetup: function(effect) {
-                      makePositioned(effect.effects[0].element); }},
+                      effect.effects[0].element.makePositioned();
-                    afterFinishInternal: function(effect) { with(Element) {
+                    },
-                      [hide, undoPositioned].call(effect.effects[0].element);
+                    afterFinishInternal: function(effect) {
-                      setStyle(effect.effects[0].element, oldStyle); }}
+                      effect.effects[0].element.hide().undoPositioned().setStyle(oldStyle);
+                    }
                   }, arguments[1] || {}));
             }
             Effect.Shake = function(element) {
               element = $(element);
               var oldStyle = {
-                top: Element.getStyle(element, 'top'),
+                top: element.getStyle('top'),
-                left: Element.getStyle(element, 'left') };
+                left: element.getStyle('left') };
-              return new Effect.MoveBy(element, 0, 20,
+                return new Effect.Move(element,
-                { duration: 0.05, afterFinishInternal: function(effect) {
+                  { x:  20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
-              new Effect.MoveBy(effect.element, 0, -40,
+                new Effect.Move(effect.element,
-                { duration: 0.1, afterFinishInternal: function(effect) {
+                  { x: -40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
-              new Effect.MoveBy(effect.element, 0, 40,
+                new Effect.Move(effect.element,
-                { duration: 0.1, afterFinishInternal: function(effect) {
+                  { x:  40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
-              new Effect.MoveBy(effect.element, 0, -40,
+                new Effect.Move(effect.element,
-                { duration: 0.1, afterFinishInternal: function(effect) {
+                  { x: -40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
-              new Effect.MoveBy(effect.element, 0, 40,
+                new Effect.Move(effect.element,
-                { duration: 0.1, afterFinishInternal: function(effect) {
+                  { x:  40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
-              new Effect.MoveBy(effect.element, 0, -20,
+                new Effect.Move(effect.element,
-                { duration: 0.05, afterFinishInternal: function(effect) { with(Element) {
+                  { x: -20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
-                    undoPositioned(effect.element);
+                    effect.element.undoPositioned().setStyle(oldStyle);
-                    setStyle(effect.element, oldStyle);
+              }}) }}) }}) }}) }}) }});
-              }}}) }}) }}) }}) }}) }});
             }
             Effect.SlideDown = function(element) {
-              element = $(element);
+              element = $(element).cleanWhitespace();
-              Element.cleanWhitespace(element);
               // SlideDown need to have the content of the element wrapped in a container element with fixed height!
-              var oldInnerBottom = Element.getStyle(element.firstChild, 'bottom');
+              var oldInnerBottom = element.down().getStyle('bottom');
-              var elementDimensions = Element.getDimensions(element);
+              var elementDimensions = element.getDimensions();
               return new Effect.Scale(element, 100, Object.extend({
                 scaleContent: false,
                 scaleX: false,
-                scaleFrom: 0,
+                scaleFrom: window.opera ? 0 : 1,
                 scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
                 restoreAfterFinish: true,
-                afterSetup: function(effect) { with(Element) {
+                afterSetup: function(effect) {
-                  makePositioned(effect.element);
+                  effect.element.makePositioned();
-                  makePositioned(effect.element.firstChild);
+                  effect.element.down().makePositioned();
-                  if(window.opera) setStyle(effect.element, {top: ''});
+                  if(window.opera) effect.element.setStyle({top: ''});
-                  makeClipping(effect.element);
+                  effect.element.makeClipping().setStyle({height: '0px'}).show();
-                  setStyle(effect.element, {height: '0px'});
+                },
-                  show(element); }},
+                afterUpdateInternal: function(effect) {
-                afterUpdateInternal: function(effect) { with(Element) {
+                  effect.element.down().setStyle({bottom:
-                  setStyle(effect.element.firstChild, {bottom:
+                    (effect.dims[0] - effect.element.clientHeight) + 'px' });
-                    (effect.dims[0] - effect.element.clientHeight) + 'px' }); }},
+                },
-                afterFinishInternal: function(effect) { with(Element) {
+                afterFinishInternal: function(effect) {
-                  undoClipping(effect.element);
+                  effect.element.undoClipping().undoPositioned();
-                  undoPositioned(effect.element.firstChild);
+                  effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); }
-                  undoPositioned(effect.element);
-                  setStyle(effect.element.firstChild, {bottom: oldInnerBottom}); }}
                 }, arguments[1] || {})
               );
             }
             Effect.SlideUp = function(element) {
-              element = $(element);
+              element = $(element).cleanWhitespace();
-              Element.cleanWhitespace(element);
+              var oldInnerBottom = element.down().getStyle('bottom');
-              var oldInnerBottom = Element.getStyle(element.firstChild, 'bottom');
+              return new Effect.Scale(element, window.opera ? 0 : 1,
-              return new Effect.Scale(element, 0,
                Object.extend({ scaleContent: false,
                 scaleX: false,
                 scaleMode: 'box',
                 scaleFrom: 100,
                 restoreAfterFinish: true,
-                beforeStartInternal: function(effect) { with(Element) {
+                beforeStartInternal: function(effect) {
-                  makePositioned(effect.element);
+                  effect.element.makePositioned();
-                  makePositioned(effect.element.firstChild);
+                  effect.element.down().makePositioned();
-                  if(window.opera) setStyle(effect.element, {top: ''});
+                  if(window.opera) effect.element.setStyle({top: ''});
-                  makeClipping(effect.element);
+                  effect.element.makeClipping().show();
-                  show(element); }},
+                },
-                afterUpdateInternal: function(effect) { with(Element) {
+                afterUpdateInternal: function(effect) {
-                  setStyle(effect.element.firstChild, {bottom:
+                  effect.element.down().setStyle({bottom:
-                    (effect.dims[0] - effect.element.clientHeight) + 'px' }); }},
+                    (effect.dims[0] - effect.element.clientHeight) + 'px' });
-                afterFinishInternal: function(effect) { with(Element) {
+                },
-                    [hide, undoClipping].call(effect.element);
+                afterFinishInternal: function(effect) {
-                    undoPositioned(effect.element.firstChild);
+                  effect.element.hide().undoClipping().undoPositioned().setStyle({bottom: oldInnerBottom});
-                    undoPositioned(effect.element);
+                  effect.element.down().undoPositioned();
-                    setStyle(effect.element.firstChild, {bottom: oldInnerBottom}); }}
                }, arguments[1] || {})
               );
             }
             // Bug in opera makes the TD containing this element expand for a instance after finish
             Effect.Squish = function(element) {
-              return new Effect.Scale(element, window.opera ? 1 : 0,
+              return new Effect.Scale(element, window.opera ? 1 : 0, {
-                { restoreAfterFinish: true,
+                restoreAfterFinish: true,
-                  beforeSetup: function(effect) { with(Element) {
+                beforeSetup: function(effect) {
-                    makeClipping(effect.element); }},
+                  effect.element.makeClipping();
-                  afterFinishInternal: function(effect) { with(Element) {
+                },
-                    hide(effect.element);
+                afterFinishInternal: function(effect) {
-                    undoClipping(effect.element); }}
+                  effect.element.hide().undoClipping();
+                }
               });
             }
             Effect.Grow = function(element) {
               element = $(element);
               var options = Object.extend({
                 direction: 'center',
-                moveTransistion: Effect.Transitions.sinoidal,
+                moveTransition: Effect.Transitions.sinoidal,
                 scaleTransition: Effect.Transitions.sinoidal,
                 opacityTransition: Effect.Transitions.full
               }, arguments[1] || {});
               var oldStyle = {
                 top: element.style.top,
                 left: element.style.left,
                 height: element.style.height,
                 width: element.style.width,
-                opacity: Element.getInlineOpacity(element) };
+                opacity: element.getInlineOpacity() };
-              var dims = Element.getDimensions(element);
+              var dims = element.getDimensions();
               var initialMoveX, initialMoveY;
               var moveX, moveY;
               switch (options.direction) {
                 case 'top-left':
                   initialMoveX = initialMoveY = moveX = moveY = 0;
                   break;
                 case 'top-right':
                   initialMoveX = dims.width;
                   initialMoveY = moveY = 0;
                   moveX = -dims.width;
                   break;
                 case 'bottom-left':
                   initialMoveX = moveX = 0;
                   initialMoveY = dims.height;
                   moveY = -dims.height;
                   break;
                 case 'bottom-right':
                   initialMoveX = dims.width;
                   initialMoveY = dims.height;
                   moveX = -dims.width;
                   moveY = -dims.height;
                   break;
                 case 'center':
                   initialMoveX = dims.width / 2;
                   initialMoveY = dims.height / 2;
                   moveX = -dims.width / 2;
                   moveY = -dims.height / 2;
                   break;
               }
-              return new Effect.MoveBy(element, initialMoveY, initialMoveX, {
+              return new Effect.Move(element, {
+                x: initialMoveX,
+                y: initialMoveY,
                 duration: 0.01,
-                beforeSetup: function(effect) { with(Element) {
+                beforeSetup: function(effect) {
-                  hide(effect.element);
+                  effect.element.hide().makeClipping().makePositioned();
-                  makeClipping(effect.element);
+                },
-                  makePositioned(effect.element);
-                }},
                 afterFinishInternal: function(effect) {
                   new Effect.Parallel(
                     [ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
-                      new Effect.MoveBy(effect.element, moveY, moveX, { sync: true, transition: options.moveTransition }),
+                      new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
                       new Effect.Scale(effect.element, 100, {
                         scaleMode: { originalHeight: dims.height, originalWidth: dims.width },
                         sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
                     ], Object.extend({
-                         beforeSetup: function(effect) { with(Element) {
+                         beforeSetup: function(effect) {
-                           setStyle(effect.effects[0].element, {height: '0px'});
+                           effect.effects[0].element.setStyle({height: '0px'}).show();
-                           show(effect.effects[0].element); }},
+                         },
-                         afterFinishInternal: function(effect) { with(Element) {
+                         afterFinishInternal: function(effect) {
-                           [undoClipping, undoPositioned].call(effect.effects[0].element);
+                           effect.effects[0].element.undoClipping().undoPositioned().setStyle(oldStyle);
-                           setStyle(effect.effects[0].element, oldStyle); }}
                        }, options)
                   )
                 }
               });
             }
             Effect.Shrink = function(element) {
               element = $(element);
               var options = Object.extend({
                 direction: 'center',
-                moveTransistion: Effect.Transitions.sinoidal,
+                moveTransition: Effect.Transitions.sinoidal,
                 scaleTransition: Effect.Transitions.sinoidal,
                 opacityTransition: Effect.Transitions.none
               }, arguments[1] || {});
               var oldStyle = {
                 top: element.style.top,
                 left: element.style.left,
                 height: element.style.height,
                 width: element.style.width,
-                opacity: Element.getInlineOpacity(element) };
+                opacity: element.getInlineOpacity() };
-              var dims = Element.getDimensions(element);
+              var dims = element.getDimensions();
               var moveX, moveY;
               switch (options.direction) {
                 case 'top-left':
                   moveX = moveY = 0;
                   break;
                 case 'top-right':
                   moveX = dims.width;
                   moveY = 0;
                   break;
                 case 'bottom-left':
                   moveX = 0;
                   moveY = dims.height;
                   break;
                 case 'bottom-right':
                   moveX = dims.width;
                   moveY = dims.height;
                   break;
                 case 'center':
                   moveX = dims.width / 2;
                   moveY = dims.height / 2;
                   break;
               }
               return new Effect.Parallel(
                 [ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
                   new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
-                  new Effect.MoveBy(element, moveY, moveX, { sync: true, transition: options.moveTransition })
+                  new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
                 ], Object.extend({
-                     beforeStartInternal: function(effect) { with(Element) {
+                     beforeStartInternal: function(effect) {
-                       [makePositioned, makeClipping].call(effect.effects[0].element) }},
+                       effect.effects[0].element.makePositioned().makeClipping();
-                     afterFinishInternal: function(effect) { with(Element) {
+                     },
-                       [hide, undoClipping, undoPositioned].call(effect.effects[0].element);
+                     afterFinishInternal: function(effect) {
-                       setStyle(effect.effects[0].element, oldStyle); }}
+                       effect.effects[0].element.hide().undoClipping().undoPositioned().setStyle(oldStyle); }
                    }, options)
               );
             }
             Effect.Pulsate = function(element) {
               element = $(element);
               var options    = arguments[1] || {};
-              var oldOpacity = Element.getInlineOpacity(element);
+              var oldOpacity = element.getInlineOpacity();
               var transition = options.transition || Effect.Transitions.sinoidal;
-              var reverser   = function(pos){ return transition(1-Effect.Transitions.pulse(pos)) };
+              var reverser   = function(pos){ return transition(1-Effect.Transitions.pulse(pos, options.pulses)) };
               reverser.bind(transition);
               return new Effect.Opacity(element,
-                Object.extend(Object.extend({  duration: 3.0, from: 0,
+                Object.extend(Object.extend({  duration: 2.0, from: 0,
-                  afterFinishInternal: function(effect) { Element.setStyle(effect.element, {opacity: oldOpacity}); }
+                  afterFinishInternal: function(effect) { effect.element.setStyle({opacity: oldOpacity}); }
                 }, options), {transition: reverser}));
             }
             Effect.Fold = function(element) {
               element = $(element);
               var oldStyle = {
                 top: element.style.top,
                 left: element.style.left,
                 width: element.style.width,
                 height: element.style.height };
-              Element.makeClipping(element);
+              element.makeClipping();
               return new Effect.Scale(element, 5, Object.extend({
                 scaleContent: false,
                 scaleX: false,
                 afterFinishInternal: function(effect) {
                 new Effect.Scale(element, 1, {
                   scaleContent: false,
                   scaleY: false,
-                  afterFinishInternal: function(effect) { with(Element) {
+                  afterFinishInternal: function(effect) {
-                    [hide, undoClipping].call(effect.element);
+                    effect.element.hide().undoClipping().setStyle(oldStyle);
-                    setStyle(effect.element, oldStyle);
+                  } });
-                  }} });
               }}, arguments[1] || {}));
+            };
+            Effect.Morph = Class.create();
+            Object.extend(Object.extend(Effect.Morph.prototype, Effect.Base.prototype), {
+              initialize: function(element) {
+                this.element = $(element);
+                if(!this.element) throw(Effect._elementDoesNotExistError);
+                var options = Object.extend({
+                  style: ''
+                }, arguments[1] || {});
+                this.start(options);
+              },
+              setup: function(){
+                function parseColor(color){
+                  if(!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
+                  color = color.parseColor();
+                  return $R(0,2).map(function(i){
+                    return parseInt( color.slice(i*2+1,i*2+3), 16 )
+                  });
+                }
+                this.transforms = this.options.style.parseStyle().map(function(property){
+                  var originalValue = this.element.getStyle(property[0]);
+                  return $H({
+                    style: property[0],
+                    originalValue: property[1].unit=='color' ?
+                      parseColor(originalValue) : parseFloat(originalValue || 0),
+                    targetValue: property[1].unit=='color' ?
+                      parseColor(property[1].value) : property[1].value,
+                    unit: property[1].unit
+                  });
+                }.bind(this)).reject(function(transform){
+                  return (
+                    (transform.originalValue == transform.targetValue) ||
+                    (
+                      transform.unit != 'color' &&
+                      (isNaN(transform.originalValue) || isNaN(transform.targetValue))
+                    )
+                  )
+                });
+              },
+              update: function(position) {
+                var style = $H(), value = null;
+                this.transforms.each(function(transform){
+                  value = transform.unit=='color' ?
+                    $R(0,2).inject('#',function(m,v,i){
+                      return m+(Math.round(transform.originalValue[i]+
+                        (transform.targetValue[i] - transform.originalValue[i])*position)).toColorPart() }) :
+                    transform.originalValue + Math.round(
+                      ((transform.targetValue - transform.originalValue) * position) * 1000)/1000 + transform.unit;
+                  style[transform.style] = value;
+                });
+                this.element.setStyle(style);
+              }
+            });
+            Effect.Transform = Class.create();
+            Object.extend(Effect.Transform.prototype, {
+              initialize: function(tracks){
+                this.tracks  = [];
+                this.options = arguments[1] || {};
+                this.addTracks(tracks);
+              },
+              addTracks: function(tracks){
+                tracks.each(function(track){
+                  var data = $H(track).values().first();
+                  this.tracks.push($H({
+                    ids:     $H(track).keys().first(),
+                    effect:  Effect.Morph,
+                    options: { style: data }
+                  }));
+                }.bind(this));
+                return this;
+              },
+              play: function(){
+                return new Effect.Parallel(
+                  this.tracks.map(function(track){
+                    var elements = [$(track.ids) || $$(track.ids)].flatten();
+                    return elements.map(function(e){ return new track.effect(e, Object.extend({ sync:true }, track.options)) });
+                  }).flatten(),
+                  this.options
+                );
+              }
+            });
+            Element.CSS_PROPERTIES = ['azimuth', 'backgroundAttachment', 'backgroundColor', 'backgroundImage',
+              'backgroundPosition', 'backgroundRepeat', 'borderBottomColor', 'borderBottomStyle',
+              'borderBottomWidth', 'borderCollapse', 'borderLeftColor', 'borderLeftStyle', 'borderLeftWidth',
+              'borderRightColor', 'borderRightStyle', 'borderRightWidth', 'borderSpacing', 'borderTopColor',
+              'borderTopStyle', 'borderTopWidth', 'bottom', 'captionSide', 'clear', 'clip', 'color', 'content',
+              'counterIncrement', 'counterReset', 'cssFloat', 'cueAfter', 'cueBefore', 'cursor', 'direction',
+              'display', 'elevation', 'emptyCells', 'fontFamily', 'fontSize', 'fontSizeAdjust', 'fontStretch',
+              'fontStyle', 'fontVariant', 'fontWeight', 'height', 'left', 'letterSpacing', 'lineHeight',
+              'listStyleImage', 'listStylePosition', 'listStyleType', 'marginBottom', 'marginLeft', 'marginRight',
+              'marginTop', 'markerOffset', 'marks', 'maxHeight', 'maxWidth', 'minHeight', 'minWidth', 'opacity',
+              'orphans', 'outlineColor', 'outlineOffset', 'outlineStyle', 'outlineWidth', 'overflowX', 'overflowY',
+              'paddingBottom', 'paddingLeft', 'paddingRight', 'paddingTop', 'page', 'pageBreakAfter', 'pageBreakBefore',
+              'pageBreakInside', 'pauseAfter', 'pauseBefore', 'pitch', 'pitchRange', 'position', 'quotes',
+              'richness', 'right', 'size', 'speakHeader', 'speakNumeral', 'speakPunctuation', 'speechRate', 'stress',
+              'tableLayout', 'textAlign', 'textDecoration', 'textIndent', 'textShadow', 'textTransform', 'top',
+              'unicodeBidi', 'verticalAlign', 'visibility', 'voiceFamily', 'volume', 'whiteSpace', 'widows',
+              'width', 'wordSpacing', 'zIndex'];
+            Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;
+            String.prototype.parseStyle = function(){
+              var element = Element.extend(document.createElement('div'));
+              element.innerHTML = '<div style="' + this + '"></div>';
+              var style = element.down().style, styleRules = $H();
+              Element.CSS_PROPERTIES.each(function(property){
+               if(style[property]) styleRules[property] = style[property];
+              });
+              var result = $H();
+              styleRules.each(function(pair){
+                var property = pair[0], value = pair[1], unit = null;
+                if(value.parseColor('#zzzzzz') != '#zzzzzz') {
+                  value = value.parseColor();
+                  unit  = 'color';
+                } else if(Element.CSS_LENGTH.test(value))
+                  var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/),
+                      value = parseFloat(components[1]), unit = (components.length == 3) ? components[2] : null;
+                result[property.underscore().dasherize()] = $H({ value:value, unit:unit });
+              }.bind(this));
+              return result;
+            };
+            Element.morph = function(element, style) {
+              new Effect.Morph(element, Object.extend({ style: style }, arguments[2] || {}));
+              return element;
+            };
+            ['setOpacity','getOpacity','getInlineOpacity','forceRerendering','setContentZoom',
+             'collectTextNodes','collectTextNodesIgnoreClass','morph'].each(
+              function(f) { Element.Methods[f] = Element[f]; }
+            );
+            Element.Methods.visualEffect = function(element, effect, options) {
+              s = effect.gsub(/_/, '-').camelize();
+              effect_class = s.charAt(0).toUpperCase() + s.substring(1);
+              new Effect[effect_class](element, options);
+              return $(element);
+            };
+            Element.addMethods();
  No newline at end of file

public/javascripts/prototype.js +377 -181

-            /*  Prototype JavaScript framework, version 1.5.0_rc1
+            /*  Prototype JavaScript framework, version 1.5.0
-             *  (c) 2005 Sam Stephenson <sam@conio.net>
+             *  (c) 2005-2007 Sam Stephenson
              *
              *  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.5.0_rc1',
+              Version: '1.5.0',
               BrowserFeatures: {
                 XPath: !!document.evaluate
               },
               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 (var property in source) {
                 destination[property] = source[property];
               }
               return destination;
             }
             Object.extend(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;
                 }
               },
               keys: function(object) {
                 var keys = [];
                 for (var property in object)
                   keys.push(property);
                 return keys;
               },
               values: function(object) {
                 var values = [];
                 for (var property in object)
                   values.push(object[property]);
                 return values;
               },
               clone: function(object) {
                 return Object.extend({}, object);
               }
             });
             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, args = $A(arguments), object = args.shift();
               return function(event) {
                 return __method.apply(object, [( event || window.event)].concat(args).concat($A(arguments)));
               }
             }
             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++) {
+                for (var i = 0, length = arguments.length; i < 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() {
                 this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
               },
               stop: function() {
                 if (!this.timer) return;
                 clearInterval(this.timer);
                 this.timer = null;
               },
               onTimerEvent: function() {
                 if (!this.currentlyExecuting) {
                   try {
                     this.currentlyExecuting = true;
                     this.callback(this);
                   } finally {
                     this.currentlyExecuting = false;
                   }
                 }
               }
             }
+            String.interpret = function(value){
+              return value == null ? '' : String(value);
+            }
             Object.extend(String.prototype, {
               gsub: function(pattern, replacement) {
                 var result = '', source = this, match;
                 replacement = arguments.callee.prepareReplacement(replacement);
                 while (source.length > 0) {
                   if (match = source.match(pattern)) {
                     result += source.slice(0, match.index);
-                    result += (replacement(match) || '').toString();
+                    result += String.interpret(replacement(match));
                     source  = source.slice(match.index + match[0].length);
                   } else {
                     result += source, source = '';
                   }
                 }
                 return result;
               },
               sub: function(pattern, replacement, count) {
                 replacement = this.gsub.prepareReplacement(replacement);
                 count = count === undefined ? 1 : count;
                 return this.gsub(pattern, function(match) {
                   if (--count < 0) return match[0];
                   return replacement(match);
                 });
               },
               scan: function(pattern, iterator) {
                 this.gsub(pattern, iterator);
                 return this;
               },
               truncate: function(length, truncation) {
                 length = length || 30;
                 truncation = truncation === undefined ? '...' : truncation;
                 return this.length > length ?
                   this.slice(0, length - truncation.length) + truncation : this;
               },
               strip: function() {
                 return this.replace(/^\s+/, '').replace(/\s+$/, '');
               },
               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(function(script) { return eval(script) });
               },
               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 : '';
+                return div.childNodes[0] ? (div.childNodes.length > 1 ?
+                  $A(div.childNodes).inject('',function(memo,node){ return memo+node.nodeValue }) :
+                  div.childNodes[0].nodeValue) : '';
               },
-              toQueryParams: function() {
+              toQueryParams: function(separator) {
-                var match = this.strip().match(/[^?]*$/)[0];
+                var match = this.strip().match(/([^?#]*)(#.*)?$/);
                 if (!match) return {};
-                var pairs = match.split('&');
-                return pairs.inject({}, function(params, pairString) {
+                return match[1].split(separator || '&').inject({}, function(hash, pair) {
-                  var pair  = pairString.split('=');
+                  if ((pair = pair.split('='))[0]) {
-                  var value = pair[1] ? decodeURIComponent(pair[1]) : undefined;
+                    var name = decodeURIComponent(pair[0]);
-                  params[decodeURIComponent(pair[0])] = value;
+                    var value = pair[1] ? decodeURIComponent(pair[1]) : undefined;
-                  return params;
+                    if (hash[name] !== undefined) {
+                      if (hash[name].constructor != Array)
+                        hash[name] = [hash[name]];
+                      if (value) hash[name].push(value);
+                    }
+                    else hash[name] = value;
+                  }
+                  return hash;
                 });
               },
               toArray: function() {
                 return this.split('');
               },
+              succ: function() {
+                return this.slice(0, this.length - 1) +
+                  String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
+              },
               camelize: function() {
-                var oStringList = this.split('-');
+                var parts = this.split('-'), len = parts.length;
-                if (oStringList.length == 1) return oStringList[0];
+                if (len == 1) return parts[0];
-                var camelizedString = this.indexOf('-') == 0
+                var camelized = this.charAt(0) == '-'
-                  ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1)
+                  ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
-                  : oStringList[0];
+                  : parts[0];
-                for (var i = 1, length = oStringList.length; i < length; i++) {
+                for (var i = 1; i < len; i++)
-                  var s = oStringList[i];
+                  camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);
-                  camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
+                return camelized;
+              },
+              capitalize: function(){
+                return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
+              },
-                return camelizedString;
+              underscore: function() {
+                return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
+              },
+              dasherize: function() {
+                return this.gsub(/_/,'-');
               },
               inspect: function(useDoubleQuotes) {
                 var escapedString = this.replace(/\\/g, '\\\\');
                 if (useDoubleQuotes)
                   return '"' + escapedString.replace(/"/g, '\\"') + '"';
                 else
                   return "'" + escapedString.replace(/'/g, '\\\'') + "'";
               }
             });
             String.prototype.gsub.prepareReplacement = function(replacement) {
               if (typeof replacement == 'function') return replacement;
               var template = new Template(replacement);
               return function(match) { return template.evaluate(match) };
             }
             String.prototype.parseQuery = String.prototype.toQueryParams;
             var Template = Class.create();
             Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
             Template.prototype = {
               initialize: function(template, pattern) {
                 this.template = template.toString();
                 this.pattern  = pattern || Template.Pattern;
               },
               evaluate: function(object) {
                 return this.template.gsub(this.pattern, function(match) {
                   var before = match[1];
                   if (before == '\\') return match[2];
-                  return before + (object[match[3]] || '').toString();
+                  return before + String.interpret(object[match[3]]);
                 });
               }
             }
             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;
                 }
                 return this;
               },
               eachSlice: function(number, iterator) {
                 var index = -number, slices = [], array = this.toArray();
                 while ((index += number) < array.length)
                   slices.push(array.slice(index, index+number));
-                return slices.collect(iterator || Prototype.K);
+                return slices.map(iterator);
               },
               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 = false;
                 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));
+                  results.push((iterator || Prototype.K)(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;
               },
               inGroupsOf: function(number, fillWith) {
-                fillWith = fillWith || null;
+                fillWith = fillWith === undefined ? null : fillWith;
-                var results = this.eachSlice(number);
+                return this.eachSlice(number, function(slice) {
-                if (results.length > 0) (number - results.last().length).times(function() {
+                  while(slice.length < number) slice.push(fillWith);
-                  results.last().push(fillWith)
+                  return slice;
                 });
-                return results;
               },
               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 this.map(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 (result == undefined || value >= result)
                     result = value;
                 });
                 return result;
               },
               min: function(iterator) {
                 var result;
                 this.each(function(value, index) {
                   value = (iterator || Prototype.K)(value, index);
                   if (result == undefined || value < result)
                     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 this.map(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);
+                return this.map();
               },
               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) {
                   return iterator(collections.pluck(index));
                 });
               },
+              size: function() {
+                return this.toArray().length;
+              },
               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, length = iterable.length; i < length; i++)
                   results.push(iterable[i]);
                 return results;
               }
             }
             Object.extend(Array.prototype, Enumerable);
             if (!Array.prototype._reverse)
               Array.prototype._reverse = Array.prototype.reverse;
             Object.extend(Array.prototype, {
               _each: function(iterator) {
                 for (var i = 0, length = this.length; i < 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;
+                  return value != null;
                 });
               },
               flatten: function() {
                 return this.inject([], function(array, value) {
                   return array.concat(value && 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, length = this.length; i < length; i++)
                   if (this[i] == object) return i;
                 return -1;
               },
               reverse: function(inline) {
                 return (inline !== false ? this : this.toArray())._reverse();
               },
               reduce: function() {
                 return this.length > 1 ? this : this[0];
               },
               uniq: function() {
                 return this.inject([], function(array, value) {
                   return array.include(value) ? array : array.concat([value]);
                 });
               },
               clone: function() {
                 return [].concat(this);
               },
+              size: function() {
+                return this.length;
+              },
               inspect: function() {
                 return '[' + this.map(Object.inspect).join(', ') + ']';
               }
             });
             Array.prototype.toArray = Array.prototype.clone;
-            var Hash = {
+            function $w(string){
+              string = string.strip();
+              return string ? string.split(/\s+/) : [];
+            }
+            if(window.opera){
+              Array.prototype.concat = function(){
+                var array = [];
+                for(var i = 0, length = this.length; i < length; i++) array.push(this[i]);
+                for(var i = 0, length = arguments.length; i < length; i++) {
+                  if(arguments[i].constructor == Array) {
+                    for(var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
+                      array.push(arguments[i][j]);
+                  } else {
+                    array.push(arguments[i]);
+                  }
+                }
+                return array;
+              }
+            }
+            var Hash = function(obj) {
+              Object.extend(this, obj || {});
+            };
+            Object.extend(Hash, {
+              toQueryString: function(obj) {
+                var parts = [];
+            	  this.prototype._each.call(obj, function(pair) {
+                  if (!pair.key) return;
+                  if (pair.value && pair.value.constructor == Array) {
+                    var values = pair.value.compact();
+                    if (values.length < 2) pair.value = values.reduce();
+                    else {
+                    	key = encodeURIComponent(pair.key);
+                      values.each(function(value) {
+                        value = value != undefined ? encodeURIComponent(value) : '';
+                        parts.push(key + '=' + encodeURIComponent(value));
+                      });
+                      return;
+                    }
+                  }
+                  if (pair.value == undefined) pair[1] = '';
+                  parts.push(pair.map(encodeURIComponent).join('='));
+            	  });
+                return parts.join('&');
+              }
+            });
+            Object.extend(Hash.prototype, Enumerable);
+            Object.extend(Hash.prototype, {
               _each: function(iterator) {
                 for (var key in this) {
                   var value = this[key];
-                  if (typeof value == 'function') continue;
+                  if (value && value == Hash.prototype[key]) 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(this, function(mergedHash, pair) {
                   mergedHash[pair.key] = pair.value;
                   return mergedHash;
                 });
               },
+              remove: function() {
+                var result;
+                for(var i = 0, length = arguments.length; i < length; i++) {
+                  var value = this[arguments[i]];
+                  if (value !== undefined){
+                    if (result === undefined) result = value;
+                    else {
+                      if (result.constructor != Array) result = [result];
+                      result.push(value)
+                    }
+                  }
+                  delete this[arguments[i]];
+                }
+                return result;
+              },
               toQueryString: function() {
-                return this.map(function(pair) {
+                return Hash.toQueryString(this);
-                  if (!pair.value && pair.value !== 0) pair[1] = '';
-                  if (!pair.key) return;
-                  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 || {});
+              if (object && object.constructor == Hash) return object;
-              Object.extend(hash, Enumerable);
+              return new Hash(object);
-              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;
                 while (this.include(value)) {
                   iterator(value);
                   value = value.succ();
                 }
               },
               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 XMLHttpRequest()},
                   function() {return new ActiveXObject('Msxml2.XMLHTTP')},
                   function() {return new ActiveXObject('Microsoft.XMLHTTP')}
                 ) || false;
               },
               activeRequestCount: 0
             }
             Ajax.Responders = {
               responders: [],
               _each: function(iterator) {
                 this.responders._each(iterator);
               },
               register: function(responder) {
                 if (!this.include(responder))
                   this.responders.push(responder);
               },
               unregister: function(responder) {
                 this.responders = this.responders.without(responder);
               },
               dispatch: function(callback, request, transport, json) {
                 this.each(function(responder) {
                   if (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,
                   contentType:  'application/x-www-form-urlencoded',
                   encoding:     'UTF-8',
                   parameters:   ''
                 }
                 Object.extend(this.options, options || {});
                 this.options.method = this.options.method.toLowerCase();
-                this.options.parameters = $H(typeof this.options.parameters == 'string' ?
+                if (typeof this.options.parameters == 'string')
-                  this.options.parameters.toQueryParams() : this.options.parameters);
+                  this.options.parameters = this.options.parameters.toQueryParams();
               }
             }
             Ajax.Request = Class.create();
             Ajax.Request.Events =
               ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
             Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
+              _complete: false,
               initialize: function(url, options) {
                 this.transport = Ajax.getTransport();
                 this.setOptions(options);
                 this.request(url);
               },
               request: function(url) {
+                this.url = url;
+                this.method = this.options.method;
                 var params = this.options.parameters;
-                if (params.any()) params['_'] = '';
-                if (!['get', 'post'].include(this.options.method)) {
+                if (!['get', 'post'].include(this.method)) {
                   // simulate other verbs over post
-                  params['_method'] = this.options.method;
+                  params['_method'] = this.method;
-                  this.options.method = 'post';
+                  this.method = 'post';
                 }
-                this.url = url;
+                params = Hash.toQueryString(params);
+                if (params && /Konqueror|Safari|KHTML/.test(navigator.userAgent)) params += '&_='
                 // when GET, append parameters to URL
-                if (this.options.method == 'get' && params.any())
+                if (this.method == 'get' && params)
-                  this.url += (this.url.indexOf('?') >= 0 ? '&' : '?') +
+                  this.url += (this.url.indexOf('?') > -1 ? '&' : '?') + params;
-                    params.toQueryString();
                 try {
                   Ajax.Responders.dispatch('onCreate', this, this.transport);
-                  this.transport.open(this.options.method.toUpperCase(), this.url,
+                  this.transport.open(this.method.toUpperCase(), this.url,
-                    this.options.asynchronous, this.options.username,
+                    this.options.asynchronous);
-                    this.options.password);
                   if (this.options.asynchronous)
                     setTimeout(function() { this.respondToReadyState(1) }.bind(this), 10);
                   this.transport.onreadystatechange = this.onStateChange.bind(this);
                   this.setRequestHeaders();
-                  var body = this.options.method == 'post' ?
+                  var body = this.method == 'post' ? (this.options.postBody || params) : null;
-                    (this.options.postBody || params.toQueryString()) : null;
                   this.transport.send(body);
                   /* Force Firefox to handle ready state 4 for synchronous requests */
                   if (!this.options.asynchronous && this.transport.overrideMimeType)
                     this.onStateChange();
                 }
                 catch (e) {
                   this.dispatchException(e);
                 }
               },
               onStateChange: function() {
                 var readyState = this.transport.readyState;
-                if (readyState > 1)
+                if (readyState > 1 && !((readyState == 4) && this._complete))
                   this.respondToReadyState(this.transport.readyState);
               },
               setRequestHeaders: function() {
                 var headers = {
                   'X-Requested-With': 'XMLHttpRequest',
                   'X-Prototype-Version': Prototype.Version,
                   'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
                 };
-                if (this.options.method == 'post') {
+                if (this.method == 'post') {
                   headers['Content-type'] = this.options.contentType +
                     (this.options.encoding ? '; charset=' + this.options.encoding : '');
                   /* Force "Connection: close" for older Mozilla browsers to work
                    * around a bug where XMLHttpRequest sends an incorrect
                    * Content-length header. See Mozilla Bugzilla #246651.
                    */
                   if (this.transport.overrideMimeType &&
                       (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
                         headers['Connection'] = 'close';
                 }
                 // user-defined headers
                 if (typeof this.options.requestHeaders == 'object') {
                   var extras = this.options.requestHeaders;
                   if (typeof extras.push == 'function')
-                    for (var i = 0; i < extras.length; i += 2)
+                    for (var i = 0, length = extras.length; i < length; i += 2)
                       headers[extras[i]] = extras[i+1];
                   else
                     $H(extras).each(function(pair) { headers[pair.key] = pair.value });
                 }
                 for (var name in headers)
                   this.transport.setRequestHeader(name, headers[name]);
               },
               success: function() {
                 return !this.transport.status
                     || (this.transport.status >= 200 && this.transport.status < 300);
               },
               respondToReadyState: function(readyState) {
                 var state = Ajax.Request.Events[readyState];
                 var transport = this.transport, json = this.evalJSON();
                 if (state == 'Complete') {
                   try {
+                    this._complete = true;
                     (this.options['on' + this.transport.status]
                      || this.options['on' + (this.success() ? 'Success' : 'Failure')]
                      || Prototype.emptyFunction)(transport, json);
                   } catch (e) {
                     this.dispatchException(e);
                   }
+                  if ((this.getHeader('Content-type') || 'text/javascript').strip().
+                    match(/^(text|application)\/(x-)?(java|ecma)script(;.*)?$/i))
+                      this.evalResponse();
                 }
                 try {
                   (this.options['on' + state] || Prototype.emptyFunction)(transport, json);
                   Ajax.Responders.dispatch('on' + state, this, transport, json);
                 } catch (e) {
                   this.dispatchException(e);
                 }
                 if (state == 'Complete') {
-                  if ((this.getHeader('Content-type') || '').strip().
-                    match(/^(text|application)\/(x-)?(java|ecma)script(;.*)?$/i))
-                      this.evalResponse();
                   // avoid memory leak in MSIE: clean up
                   this.transport.onreadystatechange = Prototype.emptyFunction;
                 }
               },
               getHeader: function(name) {
                 try {
                   return this.transport.getResponseHeader(name);
                 } catch (e) { return null }
               },
               evalJSON: function() {
                 try {
                   var json = this.getHeader('X-JSON');
                   return json ? eval('(' + json + ')') : null;
                 } catch (e) { return null }
               },
               evalResponse: function() {
                 try {
                   return eval(this.transport.responseText);
                 } catch (e) {
                   this.dispatchException(e);
                 }
               },
               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.container = {
                   success: (container.success || 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, param) {
                   this.updateContent();
                   onComplete(transport, param);
                 }).bind(this);
                 this.request(url);
               },
               updateContent: function() {
                 var receiver = this.container[this.success() ? 'success' : 'failure'];
                 var response = this.transport.responseText;
                 if (!this.options.evalScripts) response = response.stripScripts();
                 if (receiver = $(receiver)) {
                   if (this.options.insertion)
                     new this.options.insertion(receiver, response);
                   else
                     receiver.update(response);
                 }
                 if (this.success()) {
                   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.options.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);
               }
             });
             function $(element) {
               if (arguments.length > 1) {
                 for (var i = 0, elements = [], length = arguments.length; i < length; i++)
                   elements.push($(arguments[i]));
                 return elements;
               }
               if (typeof element == 'string')
                 element = document.getElementById(element);
               return Element.extend(element);
             }
             if (Prototype.BrowserFeatures.XPath) {
               document._getElementsByXPath = function(expression, parentElement) {
                 var results = [];
                 var query = document.evaluate(expression, $(parentElement) || document,
                   null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-                for (var i = 0, len = query.snapshotLength; i < len; i++)
+                for (var i = 0, length = query.snapshotLength; i < length; i++)
                   results.push(query.snapshotItem(i));
                 return results;
+              };
             }
             document.getElementsByClassName = function(className, parentElement) {
               if (Prototype.BrowserFeatures.XPath) {
                 var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
                 return document._getElementsByXPath(q, parentElement);
               } else {
                 var children = ($(parentElement) || document.body).getElementsByTagName('*');
                 var elements = [], child;
                 for (var i = 0, length = children.length; i < length; i++) {
                   child = children[i];
                   if (Element.hasClassName(child, className))
                     elements.push(Element.extend(child));
                 }
                 return elements;
               }
+            };
             /*--------------------------------------------------------------------------*/
             if (!window.Element)
               var Element = new Object();
             Element.extend = function(element) {
-              if (!element) return;
+              if (!element || _nativeExtensions || element.nodeType == 3) return element;
-              if (_nativeExtensions || element.nodeType == 3) return element;
               if (!element._extended && element.tagName && element != window) {
                 var methods = Object.clone(Element.Methods), cache = Element.extend.cache;
                 if (element.tagName == 'FORM')
                   Object.extend(methods, Form.Methods);
                 if (['INPUT', 'TEXTAREA', 'SELECT'].include(element.tagName))
                   Object.extend(methods, Form.Element.Methods);
-                for (var property in methods) {
+                Object.extend(methods, Element.Methods.Simulated);
-                  var value = methods[property];
-                  if (typeof value == 'function')
-                    element[property] = cache.findOrStore(value);
-                var methods = Object.clone(Element.Methods.Simulated), cache = Element.extend.cache;
                 for (var property in methods) {
                   var value = methods[property];
-                  if ('function' == typeof value && !(property in element))
+                  if (typeof value == 'function' && !(property in element))
                     element[property] = cache.findOrStore(value);
                 }
               }
               element._extended = true;
               return element;
+            };
             Element.extend.cache = {
               findOrStore: function(value) {
                 return this[value] = this[value] || function() {
                   return value.apply(null, [this].concat($A(arguments)));
                 }
               }
+            };
             Element.Methods = {
               visible: function(element) {
                 return $(element).style.display != 'none';
               },
               toggle: function(element) {
                 element = $(element);
                 Element[Element.visible(element) ? 'hide' : 'show'](element);
                 return element;
               },
               hide: function(element) {
                 $(element).style.display = 'none';
                 return element;
               },
               show: function(element) {
                 $(element).style.display = '';
                 return element;
               },
               remove: function(element) {
                 element = $(element);
                 element.parentNode.removeChild(element);
                 return element;
               },
               update: function(element, html) {
                 html = typeof html == 'undefined' ? '' : html.toString();
                 $(element).innerHTML = html.stripScripts();
                 setTimeout(function() {html.evalScripts()}, 10);
                 return element;
               },
               replace: function(element, html) {
                 element = $(element);
+                html = typeof html == 'undefined' ? '' : html.toString();
                 if (element.outerHTML) {
                   element.outerHTML = html.stripScripts();
                 } else {
                   var range = element.ownerDocument.createRange();
                   range.selectNodeContents(element);
                   element.parentNode.replaceChild(
                     range.createContextualFragment(html.stripScripts()), element);
                 }
                 setTimeout(function() {html.evalScripts()}, 10);
                 return element;
               },
               inspect: function(element) {
                 element = $(element);
                 var result = '<' + element.tagName.toLowerCase();
                 $H({'id': 'id', 'className': 'class'}).each(function(pair) {
                   var property = pair.first(), attribute = pair.last();
                   var value = (element[property] || '').toString();
                   if (value) result += ' ' + attribute + '=' + value.inspect(true);
                 });
                 return result + '>';
               },
               recursivelyCollect: function(element, property) {
                 element = $(element);
                 var elements = [];
                 while (element = element[property])
                   if (element.nodeType == 1)
                     elements.push(Element.extend(element));
                 return elements;
               },
               ancestors: function(element) {
                 return $(element).recursivelyCollect('parentNode');
               },
               descendants: function(element) {
-                element = $(element);
+                return $A($(element).getElementsByTagName('*'));
-                return $A(element.getElementsByTagName('*'));
+              },
+              immediateDescendants: function(element) {
+                if (!(element = $(element).firstChild)) return [];
+                while (element && element.nodeType != 1) element = element.nextSibling;
+                if (element) return [element].concat($(element).nextSiblings());
+                return [];
               },
               previousSiblings: function(element) {
                 return $(element).recursivelyCollect('previousSibling');
               },
               nextSiblings: function(element) {
                 return $(element).recursivelyCollect('nextSibling');
               },
               siblings: function(element) {
                 element = $(element);
                 return element.previousSiblings().reverse().concat(element.nextSiblings());
               },
               match: function(element, selector) {
-                element = $(element);
                 if (typeof selector == 'string')
                   selector = new Selector(selector);
-                return selector.match(element);
+                return selector.match($(element));
               },
               up: function(element, expression, index) {
                 return Selector.findElement($(element).ancestors(), expression, index);
               },
               down: function(element, expression, index) {
                 return Selector.findElement($(element).descendants(), expression, index);
               },
               previous: function(element, expression, index) {
                 return Selector.findElement($(element).previousSiblings(), expression, index);
               },
               next: function(element, expression, index) {
                 return Selector.findElement($(element).nextSiblings(), expression, index);
               },
               getElementsBySelector: function() {
                 var args = $A(arguments), element = $(args.shift());
                 return Selector.findChildElements(element, args);
               },
               getElementsByClassName: function(element, className) {
-                element = $(element);
                 return document.getElementsByClassName(className, element);
               },
-              getHeight: function(element) {
+              readAttribute: function(element, name) {
                 element = $(element);
-                return element.offsetHeight;
+                if (document.all && !window.opera) {
+                  var t = Element._attributeTranslations;
+                  if (t.values[name]) return t.values[name](element, name);
+                  if (t.names[name])  name = t.names[name];
+                  var attribute = element.attributes[name];
+                  if(attribute) return attribute.nodeValue;
+                }
+                return element.getAttribute(name);
+              },
+              getHeight: function(element) {
+                return $(element).getDimensions().height;
+              },
+              getWidth: function(element) {
+                return $(element).getDimensions().width;
               },
               classNames: function(element) {
                 return new Element.ClassNames(element);
               },
               hasClassName: function(element, className) {
                 if (!(element = $(element))) return;
                 var elementClassName = element.className;
                 if (elementClassName.length == 0) return false;
                 if (elementClassName == className ||
                     elementClassName.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
                   return true;
                 return false;
               },
               addClassName: function(element, className) {
                 if (!(element = $(element))) return;
                 Element.classNames(element).add(className);
                 return element;
               },
               removeClassName: function(element, className) {
                 if (!(element = $(element))) return;
                 Element.classNames(element).remove(className);
                 return element;
               },
+              toggleClassName: function(element, className) {
+                if (!(element = $(element))) return;
+                Element.classNames(element)[element.hasClassName(className) ? 'remove' : 'add'](className);
+                return element;
+              },
               observe: function() {
                 Event.observe.apply(Event, arguments);
                 return $A(arguments).first();
               },
               stopObserving: function() {
                 Event.stopObserving.apply(Event, arguments);
                 return $A(arguments).first();
               },
               // removes whitespace-only text node children
               cleanWhitespace: function(element) {
                 element = $(element);
                 var node = element.firstChild;
                 while (node) {
                   var nextNode = node.nextSibling;
                   if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
                     element.removeChild(node);
                   node = nextNode;
                 }
                 return element;
               },
               empty: function(element) {
                 return $(element).innerHTML.match(/^\s*$/);
               },
-              childOf: function(element, ancestor) {
+              descendantOf: function(element, ancestor) {
                 element = $(element), ancestor = $(ancestor);
                 while (element = element.parentNode)
                   if (element == ancestor) return true;
                 return false;
               },
               scrollTo: function(element) {
                 element = $(element);
-                var x = element.x ? element.x : element.offsetLeft,
+                var pos = Position.cumulativeOffset(element);
-                    y = element.y ? element.y : element.offsetTop;
+                window.scrollTo(pos[0], pos[1]);
-                window.scrollTo(x, y);
                 return element;
               },
               getStyle: function(element, style) {
                 element = $(element);
-                var value = element.style[style.camelize()];
+                if (['float','cssFloat'].include(style))
+                  style = (typeof element.style.styleFloat != 'undefined' ? 'styleFloat' : 'cssFloat');
+                style = style.camelize();
+                var value = element.style[style];
                 if (!value) {
                   if (document.defaultView && document.defaultView.getComputedStyle) {
                     var css = document.defaultView.getComputedStyle(element, null);
-                    value = css ? css.getPropertyValue(style) : null;
+                    value = css ? css[style] : null;
                   } else if (element.currentStyle) {
-                    value = element.currentStyle[style.camelize()];
+                    value = element.currentStyle[style];
                   }
                 }
+                if((value == 'auto') && ['width','height'].include(style) && (element.getStyle('display') != 'none'))
+                  value = element['offset'+style.capitalize()] + 'px';
                 if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
                   if (Element.getStyle(element, 'position') == 'static') value = 'auto';
+                if(style == 'opacity') {
+                  if(value) return parseFloat(value);
+                  if(value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
+                    if(value[1]) return parseFloat(value[1]) / 100;
+                  return 1.0;
+                }
                 return value == 'auto' ? null : value;
               },
               setStyle: function(element, style) {
                 element = $(element);
-                for (var name in style)
+                for (var name in style) {
-                  element.style[name.camelize()] = style[name];
+                  var value = style[name];
+                  if(name == 'opacity') {
+                    if (value == 1) {
+                      value = (/Gecko/.test(navigator.userAgent) &&
+                        !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 0.999999 : 1.0;
+                      if(/MSIE/.test(navigator.userAgent) && !window.opera)
+                        element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'');
+                    } else if(value == '') {
+                      if(/MSIE/.test(navigator.userAgent) && !window.opera)
+                        element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'');
+                    } else {
+                      if(value < 0.00001) value = 0;
+                      if(/MSIE/.test(navigator.userAgent) && !window.opera)
+                        element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'') +
+                          'alpha(opacity='+value*100+')';
+                    }
+                  } else if(['float','cssFloat'].include(name)) name = (typeof element.style.styleFloat != 'undefined') ? 'styleFloat' : 'cssFloat';
+                  element.style[name.camelize()] = value;
+                }
                 return element;
               },
               getDimensions: function(element) {
                 element = $(element);
-                if (Element.getStyle(element, 'display') != 'none')
+                var display = $(element).getStyle('display');
+                if (display != 'none' && display != null) // Safari bug
                   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;
+                var originalDisplay = els.display;
                 els.visibility = 'hidden';
                 els.position = 'absolute';
-                els.display = '';
+                els.display = 'block';
                 var originalWidth = element.clientWidth;
                 var originalHeight = element.clientHeight;
-                els.display = 'none';
+                els.display = originalDisplay;
                 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;
                   }
                 }
                 return element;
               },
               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 = '';
                 }
                 return element;
               },
               makeClipping: function(element) {
                 element = $(element);
                 if (element._overflow) return element;
                 element._overflow = element.style.overflow || 'auto';
                 if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
                   element.style.overflow = 'hidden';
                 return element;
               },
               undoClipping: function(element) {
                 element = $(element);
                 if (!element._overflow) return element;
                 element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
                 element._overflow = null;
                 return element;
               }
+            };
+            Object.extend(Element.Methods, {childOf: Element.Methods.descendantOf});
+            Element._attributeTranslations = {};
+            Element._attributeTranslations.names = {
+              colspan:   "colSpan",
+              rowspan:   "rowSpan",
+              valign:    "vAlign",
+              datetime:  "dateTime",
+              accesskey: "accessKey",
+              tabindex:  "tabIndex",
+              enctype:   "encType",
+              maxlength: "maxLength",
+              readonly:  "readOnly",
+              longdesc:  "longDesc"
+            };
+            Element._attributeTranslations.values = {
+              _getAttr: function(element, attribute) {
+                return element.getAttribute(attribute, 2);
+              },
+              _flag: function(element, attribute) {
+                return $(element).hasAttribute(attribute) ? attribute : null;
+              },
+              style: function(element) {
+                return element.style.cssText.toLowerCase();
+              },
+              title: function(element) {
+                var node = element.getAttributeNode('title');
+                return node.specified ? node.nodeValue : null;
+              }
+            };
+            Object.extend(Element._attributeTranslations.values, {
+              href: Element._attributeTranslations.values._getAttr,
+              src:  Element._attributeTranslations.values._getAttr,
+              disabled: Element._attributeTranslations.values._flag,
+              checked:  Element._attributeTranslations.values._flag,
+              readonly: Element._attributeTranslations.values._flag,
+              multiple: Element._attributeTranslations.values._flag
+            });
             Element.Methods.Simulated = {
               hasAttribute: function(element, attribute) {
+                var t = Element._attributeTranslations;
+                attribute = t.names[attribute] || attribute;
                 return $(element).getAttributeNode(attribute).specified;
               }
+            };
             // IE is missing .innerHTML support for TABLE-related elements
-            if(document.all){
+            if (document.all && !window.opera){
               Element.Methods.update = function(element, html) {
                 element = $(element);
                 html = typeof html == 'undefined' ? '' : html.toString();
                 var tagName = element.tagName.toUpperCase();
-                if (['THEAD','TBODY','TR','TD'].indexOf(tagName) > -1) {
+                if (['THEAD','TBODY','TR','TD'].include(tagName)) {
                   var div = document.createElement('div');
                   switch (tagName) {
                     case 'THEAD':
                     case 'TBODY':
                       div.innerHTML = '<table><tbody>' +  html.stripScripts() + '</tbody></table>';
                       depth = 2;
                       break;
                     case 'TR':
                       div.innerHTML = '<table><tbody><tr>' +  html.stripScripts() + '</tr></tbody></table>';
                       depth = 3;
                       break;
                     case 'TD':
                       div.innerHTML = '<table><tbody><tr><td>' +  html.stripScripts() + '</td></tr></tbody></table>';
                       depth = 4;
                   }
                   $A(element.childNodes).each(function(node){
                     element.removeChild(node)
                   });
                   depth.times(function(){ div = div.firstChild });
                   $A(div.childNodes).each(
                     function(node){ element.appendChild(node) });
                 } else {
                   element.innerHTML = html.stripScripts();
                 }
                 setTimeout(function() {html.evalScripts()}, 10);
                 return element;
               }
+            };
             Object.extend(Element, Element.Methods);
             var _nativeExtensions = false;
             if(/Konqueror|Safari|KHTML/.test(navigator.userAgent))
               ['', 'Form', 'Input', 'TextArea', 'Select'].each(function(tag) {
                 var className = 'HTML' + tag + 'Element';
                 if(window[className]) return;
                 var klass = window[className] = {};
                 klass.prototype = document.createElement(tag ? tag.toLowerCase() : 'div').__proto__;
               });
             Element.addMethods = function(methods) {
               Object.extend(Element.Methods, methods || {});
               function copy(methods, destination, onlyIfAbsent) {
                 onlyIfAbsent = onlyIfAbsent || false;
                 var cache = Element.extend.cache;
                 for (var property in methods) {
                   var value = methods[property];
                   if (!onlyIfAbsent || !(property in destination))
                     destination[property] = cache.findOrStore(value);
                 }
               }
               if (typeof HTMLElement != 'undefined') {
                 copy(Element.Methods, HTMLElement.prototype);
                 copy(Element.Methods.Simulated, HTMLElement.prototype, true);
                 copy(Form.Methods, HTMLFormElement.prototype);
                 [HTMLInputElement, HTMLTextAreaElement, HTMLSelectElement].each(function(klass) {
                   copy(Form.Element.Methods, klass.prototype);
                 });
                 _nativeExtensions = true;
               }
             }
             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) {
-                    var tagName = this.element.tagName.toLowerCase();
+                    var tagName = this.element.tagName.toUpperCase();
-                    if (tagName == 'tbody' || tagName == 'tr') {
+                    if (['TBODY', 'TR'].include(tagName)) {
                       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($A(this).concat(classNameToAdd).join(' '));
               },
               remove: function(classNameToRemove) {
                 if (!this.include(classNameToRemove)) return;
                 this.set($A(this).without(classNameToRemove).join(' '));
               },
               toString: function() {
                 return $A(this).join(' ');
               }
+            };
             Object.extend(Element.ClassNames.prototype, Enumerable);
             var Selector = Class.create();
             Selector.prototype = {
               initialize: function(expression) {
                 this.params = {classNames: []};
                 this.expression = expression.toString().strip();
                 this.parseExpression();
                 this.compileMatcher();
               },
               parseExpression: function() {
                 function abort(message) { throw 'Parse error in selector: ' + message; }
                 if (this.expression == '')  abort('empty expression');
                 var params = this.params, expr = this.expression, match, modifier, clause, rest;
                 while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)) {
                   params.attributes = params.attributes || [];
                   params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
                   expr = match[1];
                 }
                 if (expr == '*') return this.params.wildcard = true;
                 while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+)(.*)/i)) {
                   modifier = match[1], clause = match[2], rest = match[3];
                   switch (modifier) {
                     case '#':       params.id = clause; break;
                     case '.':       params.classNames.push(clause); break;
                     case '':
                     case undefined: params.tagName = clause.toUpperCase(); break;
                     default:        abort(expr.inspect());
                   }
                   expr = rest;
                 }
                 if (expr.length > 0) abort(expr.inspect());
               },
               buildMatchExpression: function() {
                 var params = this.params, conditions = [], clause;
                 if (params.wildcard)
                   conditions.push('true');
                 if (clause = params.id)
-                  conditions.push('element.id == ' + clause.inspect());
+                  conditions.push('element.readAttribute("id") == ' + clause.inspect());
                 if (clause = params.tagName)
                   conditions.push('element.tagName.toUpperCase() == ' + clause.inspect());
                 if ((clause = params.classNames).length > 0)
-                  for (var i = 0; i < clause.length; i++)
+                  for (var i = 0, length = clause.length; i < length; i++)
-                    conditions.push('Element.hasClassName(element, ' + clause[i].inspect() + ')');
+                    conditions.push('element.hasClassName(' + clause[i].inspect() + ')');
                 if (clause = params.attributes) {
                   clause.each(function(attribute) {
-                    var value = 'element.getAttribute(' + attribute.name.inspect() + ')';
+                    var value = 'element.readAttribute(' + attribute.name.inspect() + ')';
                     var splitValueBy = function(delimiter) {
                       return value + ' && ' + value + '.split(' + delimiter.inspect() + ')';
                     }
                     switch (attribute.operator) {
                       case '=':       conditions.push(value + ' == ' + attribute.value.inspect()); break;
                       case '~=':      conditions.push(splitValueBy(' ') + '.include(' + attribute.value.inspect() + ')'); break;
                       case '|=':      conditions.push(
                                         splitValueBy('-') + '.first().toUpperCase() == ' + attribute.value.toUpperCase().inspect()
                                       ); break;
                       case '!=':      conditions.push(value + ' != ' + attribute.value.inspect()); break;
                       case '':
-                      case undefined: conditions.push(value + ' != null'); break;
+                      case undefined: conditions.push('element.hasAttribute(' + attribute.name.inspect() + ')'); break;
                       default:        throw 'Unknown operator ' + attribute.operator + ' in selector';
                     }
                   });
                 }
                 return conditions.join(' && ');
               },
               compileMatcher: function() {
                 this.match = new Function('element', 'if (!element.tagName) return false; \
+                  element = $(element); \
                   return ' + this.buildMatchExpression());
               },
               findElements: function(scope) {
                 var element;
                 if (element = $(this.params.id))
                   if (this.match(element))
                     if (!scope || Element.childOf(element, scope))
                       return [element];
                 scope = (scope || document).getElementsByTagName(this.params.tagName || '*');
                 var results = [];
                 for (var i = 0, length = scope.length; i < length; i++)
                   if (this.match(element = scope[i]))
                     results.push(Element.extend(element));
                 return results;
               },
               toString: function() {
                 return this.expression;
               }
             }
             Object.extend(Selector, {
               matchElements: function(elements, expression) {
                 var selector = new Selector(expression);
-                return elements.select(selector.match.bind(selector)).collect(Element.extend);
+                return elements.select(selector.match.bind(selector)).map(Element.extend);
               },
               findElement: function(elements, expression, index) {
                 if (typeof expression == 'number') index = expression, expression = false;
                 return Selector.matchElements(elements, expression || '*')[index || 0];
               },
               findChildElements: function(element, expressions) {
                 return expressions.map(function(expression) {
-                  return expression.strip().split(/\s+/).inject([null], function(results, expr) {
+                  return expression.match(/[^\s"]+(?:"[^"]*"[^\s"]+)*/g).inject([null], function(results, expr) {
                     var selector = new Selector(expr);
                     return results.inject([], function(elements, result) {
                       return elements.concat(selector.findElements(result || element));
                     });
                   });
                 }).flatten();
               }
             });
             function $$() {
               return Selector.findChildElements(document, $A(arguments));
             }
             var Form = {
               reset: function(form) {
                 $(form).reset();
                 return form;
               },
-              serializeElements: function(elements) {
+              serializeElements: function(elements, getHash) {
-                return elements.inject([], function(queryComponents, element) {
+                var data = elements.inject({}, function(result, element) {
-                  var queryComponent = Form.Element.serialize(element);
+                  if (!element.disabled && element.name) {
-                  if (queryComponent) queryComponents.push(queryComponent);
+                    var key = element.name, value = $(element).getValue();
-                  return queryComponents;
+                    if (value != undefined) {
-                }).join('&');
+                      if (result[key]) {
+                        if (result[key].constructor != Array) result[key] = [result[key]];
+                        result[key].push(value);
+                      }
+                      else result[key] = value;
+                    }
+                  }
+                  return result;
+                });
+                return getHash ? data : Hash.toQueryString(data);
               }
             };
             Form.Methods = {
-              serialize: function(form) {
+              serialize: function(form, getHash) {
-                return Form.serializeElements($(form).getElements());
+                return Form.serializeElements(Form.getElements(form), getHash);
               },
               getElements: function(form) {
                 return $A($(form).getElementsByTagName('*')).inject([],
                   function(elements, child) {
                     if (Form.Element.Serializers[child.tagName.toLowerCase()])
                       elements.push(Element.extend(child));
                     return elements;
                   }
                 );
               },
               getInputs: function(form, typeName, name) {
                 form = $(form);
                 var inputs = form.getElementsByTagName('input');
-                if (!typeName && !name)
+                if (!typeName && !name) return $A(inputs).map(Element.extend);
-                  return inputs;
-                var matchingInputs = new Array();
+                for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
-                for (var i = 0, length = inputs.length; i < length; i++) {
                   var input = inputs[i];
-                  if ((typeName && input.type != typeName) ||
+                  if ((typeName && input.type != typeName) || (name && input.name != name))
-                      (name && input.name != name))
                     continue;
                   matchingInputs.push(Element.extend(input));
                 }
                 return matchingInputs;
               },
               disable: function(form) {
                 form = $(form);
                 form.getElements().each(function(element) {
                   element.blur();
                   element.disabled = 'true';
                 });
                 return form;
               },
               enable: function(form) {
                 form = $(form);
                 form.getElements().each(function(element) {
                   element.disabled = '';
                 });
                 return form;
               },
               findFirstElement: function(form) {
                 return $(form).getElements().find(function(element) {
                   return element.type != 'hidden' && !element.disabled &&
                     ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
                 });
               },
               focusFirstElement: function(form) {
                 form = $(form);
                 form.findFirstElement().activate();
                 return form;
               }
             }
             Object.extend(Form, Form.Methods);
             /*--------------------------------------------------------------------------*/
             Form.Element = {
               focus: function(element) {
                 $(element).focus();
                 return element;
               },
               select: function(element) {
                 $(element).select();
                 return element;
               }
             }
             Form.Element.Methods = {
               serialize: function(element) {
                 element = $(element);
-                if (element.disabled) return '';
+                if (!element.disabled && element.name) {
-                var method = element.tagName.toLowerCase();
+                  var value = element.getValue();
-                var parameter = Form.Element.Serializers[method](element);
+                  if (value != undefined) {
+                    var pair = {};
-                if (parameter) {
+                    pair[element.name] = value;
-                  var key = encodeURIComponent(parameter[0]);
+                    return Hash.toQueryString(pair);
-                  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('&');
                 }
+                return '';
               },
               getValue: function(element) {
                 element = $(element);
                 var method = element.tagName.toLowerCase();
-                var parameter = Form.Element.Serializers[method](element);
+                return Form.Element.Serializers[method](element);
-                if (parameter)
-                  return parameter[1];
               },
               clear: function(element) {
                 $(element).value = '';
                 return element;
               },
               present: function(element) {
                 return $(element).value != '';
               },
               activate: function(element) {
                 element = $(element);
                 element.focus();
-                if (element.select)
+                if (element.select && ( element.tagName.toLowerCase() != 'input' ||
+                  !['button', 'reset', 'submit'].include(element.type) ) )
                   element.select();
                 return element;
               },
               disable: function(element) {
                 element = $(element);
                 element.disabled = true;
                 return element;
               },
               enable: function(element) {
                 element = $(element);
                 element.blur();
                 element.disabled = false;
                 return element;
               }
             }
             Object.extend(Form.Element, Form.Element.Methods);
             var Field = Form.Element;
+            var $F = Form.Element.getValue;
             /*--------------------------------------------------------------------------*/
             Form.Element.Serializers = {
               input: function(element) {
                 switch (element.type.toLowerCase()) {
                   case 'checkbox':
                   case 'radio':
                     return Form.Element.Serializers.inputSelector(element);
                   default:
                     return Form.Element.Serializers.textarea(element);
                 }
-                return false;
               },
               inputSelector: function(element) {
-                if (element.checked)
+                return element.checked ? element.value : null;
-                  return [element.name, element.value];
               },
               textarea: function(element) {
-                return [element.name, element.value];
+                return element.value;
               },
               select: function(element) {
-                return Form.Element.Serializers[element.type == 'select-one' ?
+                return this[element.type == 'select-one' ?
                   'selectOne' : 'selectMany'](element);
               },
               selectOne: function(element) {
-                var value = '', opt, index = element.selectedIndex;
+                var index = element.selectedIndex;
-                if (index >= 0) {
+                return index >= 0 ? this.optionValue(element.options[index]) : null;
-                  opt = Element.extend(element.options[index]);
-                  // Uses the new potential extension if hasAttribute isn't native.
-                  value = opt.hasAttribute('value') ? opt.value : opt.text;
-                return [element.name, value];
               },
               selectMany: function(element) {
-                var value = [];
+                var values, length = element.length;
-                for (var i = 0; i < element.length; i++) {
+                if (!length) return null;
-                  var opt = Element.extend(element.options[i]);
-                  if (opt.selected)
+                for (var i = 0, values = []; i < length; i++) {
-                    // Uses the new potential extension if hasAttribute isn't native.
+                  var opt = element.options[i];
-                    value.push(opt.hasAttribute('value') ? opt.value : opt.text);
+                  if (opt.selected) values.push(this.optionValue(opt));
                 }
-                return [element.name, value];
+                return values;
+              },
+              optionValue: function(opt) {
+                // extend element because hasAttribute may not be native
+                return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
               }
             }
             /*--------------------------------------------------------------------------*/
-            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) {
+                var changed = ('string' == typeof this.lastValue && 'string' == typeof value
+                  ? this.lastValue != value : String(this.lastValue) != String(value));
+                if (changed) {
                   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() {
                 Form.getElements(this.element).each(this.registerCallback.bind(this));
               },
               registerCallback: function(element) {
                 if (element.type) {
                   switch (element.type.toLowerCase()) {
                     case 'checkbox':
                     case 'radio':
                       Event.observe(element, 'click', this.onElementEvent.bind(this));
                       break;
                     default:
                       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,
               KEY_HOME:     36,
               KEY_END:      35,
               KEY_PAGEUP:   33,
               KEY_PAGEDOWN: 34,
               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, length = Event.observers.length; i < length; i++) {
                   Event.stopObserving.apply(this, Event.observers[i]);
                   Event.observers[i][0] = null;
                 }
                 Event.observers = false;
               },
               observe: function(element, name, observer, useCapture) {
                 element = $(element);
                 useCapture = useCapture || false;
                 if (name == 'keypress' &&
                     (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
                     || element.attachEvent))
                   name = 'keydown';
                 Event._observeAndCache(element, name, observer, useCapture);
               },
               stopObserving: function(element, name, observer, useCapture) {
                 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) {
                   try {
                     element.detachEvent('on' + name, observer);
                   } catch (e) {}
                 }
               }
             });
             /* prevent memory leaks in IE */
             if (navigator.appVersion.match(/\bMSIE\b/))
               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) {
                     if(element.tagName=='BODY') break;
                     var 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;
               },
               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 {
                   if (!window.opera || element.tagName=='BODY') {
                     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.top    = top + 'px';
-                element.style.left   = left + 'px';;
+                element.style.left   = left + 'px';
-                element.style.width  = width + 'px';;
+                element.style.width  = width + 'px';
-                element.style.height = height + '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];
               }
             }
             Element.addMethods();

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages