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
             // 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 = {
                 this.index       = 0;
                 this.entryCount  = 0;
-                if (this.setOptions)
+                if(this.setOptions)
                   this.setOptions(options);
                 else
                   this.options = options || {};
                 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;
               },
               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);
                      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;
                     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)
               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) {
                   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);
                 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.stopIndicator();
                   this.index = 0;
-                  this.render();
+                  if(this.entryCount==1 && this.options.autoSelect) {
+                    this.selectEntry();
+                    this.hide();
+                  } else {
+                    this.render();
+                  }
                 }
               },
             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.element = $(element);
                 this.options = Object.extend({
+                  paramName: "value",
+                  okButton: true,
                   okText: "ok",
+                  cancelLink: true,
                   cancelText: "cancel",
                   savingText: "Saving...",
                   clickToEditText: "Click to edit",
                   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) {
                 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);
                   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;
                 } 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;
                 }
                 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();
                 // 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]);
               }
             };
+            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
                 this.timer = null;
                 this.callback(this.element, $F(this.element));
               }
-            };
  No newline at end of file
+            };

public/javascripts/dragdrop.js +454 -96

This diff has been collapsed as it changes many lines, (550 lines changed) Show them Hide them
	@@ -1,8 +1,11
	1	// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)	1	// Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
			2	// (c) 2005, 2006 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
	2	//	3	//
	3	// See scriptaculous.js for full license.	4	// script.aculo.us is freely distributable under the terms of an MIT-style license.
			5	// For details, see the script.aculo.us web site: http://script.aculo.us/
	4		6
	5	/--------------------------------------------------------------------------/	7	if(typeof Effect == 'undefined')
			8	throw("dragdrop.js requires including script.aculo.us' effects.js library");
	6		9
	7	var Droppables = {	10	var Droppables = {
	8	drops: [],	11	drops: [],
	@@ -15,7 +18,8 var Droppables = {
	15	element = $(element);	18	element = $(element);
	16	var options = Object.extend({	19	var options = Object.extend({
	17	greedy: true,	20	greedy: true,
	18	hoverclass: null	21	hoverclass: null,
			22	tree: false
	19	}, arguments[1] \|\| {});	23	}, arguments[1] \|\| {});
	20		24
	21	// cache containers	25	// cache containers
	@@ -37,12 +41,27 var Droppables = {
	37		41
	38	this.drops.push(options);	42	this.drops.push(options);
	39	},	43	},
			44
			45	findDeepestChild: function(drops) {
			46	deepest = drops[0];
			47
			48	for (i = 1; i < drops.length; ++i)
			49	if (Element.isParent(drops[i].element, deepest.element))
			50	deepest = drops[i];
			51
			52	return deepest;
			53	},
	40		54
	41	isContained: function(element, drop) {	55	isContained: function(element, drop) {
	42	var parentNode = element.parentNode;	56	var containmentNode;
	43	return drop._containers.detect(function(c) { return parentNode == c });	57	if(drop.tree) {
			58	containmentNode = element.treeNode;
			59	} else {
			60	containmentNode = element.parentNode;
			61	}
			62	return drop._containers.detect(function(c) { return containmentNode == c });
	44	},	63	},
	45		64
	46	isAffected: function(point, element, drop) {	65	isAffected: function(point, element, drop) {
	47	return (	66	return (
	48	(drop.element!=element) &&	67	(drop.element!=element) &&
	@@ -68,18 +87,22 var Droppables = {
	68		87
	69	show: function(point, element) {	88	show: function(point, element) {
	70	if(!this.drops.length) return;	89	if(!this.drops.length) return;
			90	var affected = [];
	71		91
	72	if(this.last_active) this.deactivate(this.last_active);	92	if(this.last_active) this.deactivate(this.last_active);
	73	this.drops.each( function(drop) {	93	this.drops.each( function(drop) {
	74	if(Droppables.isAffected(point, element, drop)) {	94	if(Droppables.isAffected(point, element, drop))
	75	if(drop.onHover)	95	affected.push(drop);
	76	drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
	77	if(drop.greedy) {
	78	Droppables.activate(drop);
	79	throw $break;
	80	}
	81	}
	82	});	96	});
			97
			98	if(affected.length>0) {
			99	drop = Droppables.findDeepestChild(affected);
			100	Position.within(drop.element, point[0], point[1]);
			101	if(drop.onHover)
			102	drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
			103
			104	Droppables.activate(drop);
			105	}
	83	},	106	},
	84		107
	85	fire: function(event, element) {	108	fire: function(event, element) {
	@@ -124,11 +147,19 var Draggables = {
	124	},	147	},
	125		148
	126	activate: function(draggable) {	149	activate: function(draggable) {
	127	window.focus(); // allows keypress events if window isn't currently focused, fails for Safari	150	if(draggable.options.delay) {
	128	this.activeDraggable = draggable;	151	this._timeout = setTimeout(function() {
			152	Draggables._timeout = null;
			153	window.focus();
			154	Draggables.activeDraggable = draggable;
			155	}.bind(this), draggable.options.delay);
			156	} else {
			157	window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
			158	this.activeDraggable = draggable;
			159	}
	129	},	160	},
	130		161
	131	deactivate: function(~~draggbale~~) {	162	deactivate: function() {
	132	this.activeDraggable = null;	163	this.activeDraggable = null;
	133	},	164	},
	134		165
	@@ -139,13 +170,19 var Draggables = {
	139	// the same coordinates, prevent needless redrawing (moz bug?)	170	// the same coordinates, prevent needless redrawing (moz bug?)
	140	if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;	171	if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
	141	this._lastPointer = pointer;	172	this._lastPointer = pointer;
			173
	142	this.activeDraggable.updateDrag(event, pointer);	174	this.activeDraggable.updateDrag(event, pointer);
	143	},	175	},
	144		176
	145	endDrag: function(event) {	177	endDrag: function(event) {
			178	if(this._timeout) {
			179	clearTimeout(this._timeout);
			180	this._timeout = null;
			181	}
	146	if(!this.activeDraggable) return;	182	if(!this.activeDraggable) return;
	147	this._lastPointer = null;	183	this._lastPointer = null;
	148	this.activeDraggable.endDrag(event);	184	this.activeDraggable.endDrag(event);
			185	this.activeDraggable = null;
	149	},	186	},
	150		187
	151	keyPress: function(event) {	188	keyPress: function(event) {
	@@ -168,6 +205,7 var Draggables = {
	168	this.observers.each( function(o) {	205	this.observers.each( function(o) {
	169	if(o[eventName]) o[eventName](eventName, draggable, event);	206	if(o[eventName]) o[eventName](eventName, draggable, event);
	170	});	207	});
			208	if(draggable.options[eventName]) draggable.options[eventName](draggable, event);
	171	},	209	},
	172		210
	173	_cacheObserverCallbacks: function() {	211	_cacheObserverCallbacks: function() {
	@@ -182,31 +220,59 var Draggables = {
	182	/--------------------------------------------------------------------------/	220	/--------------------------------------------------------------------------/
	183		221
	184	var Draggable = Class.create();	222	var Draggable = Class.create();
			223	Draggable._dragging = {};
			224
	185	Draggable.prototype = {	225	Draggable.prototype = {
	186	initialize: function(element) {	226	initialize: function(element) {
	187	var options = Object.extend({	227	var defaults = {
	188	handle: false,	228	handle: false,
	189	starteffect: function(element) {
	190	new Effect.Opacity(element, {duration:0.2, from:1.0, to:0.7});
	191	},
	192	reverteffect: function(element, top_offset, left_offset) {	229	reverteffect: function(element, top_offset, left_offset) {
	193	var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;	230	var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
	194	~~element~~.~~_revert~~ = new Effect.MoveBy(element, -top_offset, -~~left_offset~~, {duration:dur~~});~~	231	new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur,
			232	queue: {scope:'_draggable', position:'end'}
			233	});
	195	},	234	},
	196	endeffect: function(element) {	235	endeffect: function(element) {
	197	new Effect.Opacity(element, {duration:0.2, from:0.7, to:1.0});	236	var toOpacity = typeof element._opacity == 'number' ? element._opacity : 1.0;
			237	new Effect.Opacity(element, {duration:0.2, from:0.7, to:toOpacity,
			238	queue: {scope:'_draggable', position:'end'},
			239	afterFinish: function(){
			240	Draggable._dragging[element] = false
			241	}
			242	});
	198	},	243	},
	199	zindex: 1000,	244	zindex: 1000,
	200	revert: false,	245	revert: false,
	201	snap: false // false, or xy or [x,y] or function(x,y){ return [x,y] }	246	scroll: false,
	202	}, arguments[1] \|\| {});	247	scrollSensitivity: 20,
			248	scrollSpeed: 15,
			249	snap: false, // false, or xy or [x,y] or function(x,y){ return [x,y] }
			250	delay: 0
			251	};
			252
			253	if(!arguments[1] \|\| typeof arguments[1].endeffect == 'undefined')
			254	Object.extend(defaults, {
			255	starteffect: function(element) {
			256	element._opacity = Element.getOpacity(element);
			257	Draggable._dragging[element] = true;
			258	new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7});
			259	}
			260	});
			261
			262	var options = Object.extend(defaults, arguments[1] \|\| {});
	203		263
	204	this.element = $(element);	264	this.element = $(element);
	205		265
	206	if(options.handle && (typeof options.handle == 'string'))	266	if(options.handle && (typeof options.handle == 'string'))
	207	this.handle = ~~Element~~.~~childrenWithClassName~~(this.element, options.handle)[0];	267	this.handle = this.element.down('.'+options.handle, 0);
			268
	208	if(!this.handle) this.handle = $(options.handle);	269	if(!this.handle) this.handle = $(options.handle);
	209	if(!this.handle) this.handle = this.element;	270	if(!this.handle) this.handle = this.element;
			271
			272	if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
			273	options.scroll = $(options.scroll);
			274	this._isScrollChild = Element.childOf(this.element, options.scroll);
			275	}
	210		276
	211	Element.makePositioned(this.element); // fix IE	277	Element.makePositioned(this.element); // fix IE
	212		278
	@@ -227,25 +293,23 Draggable.prototype = {
	227		293
	228	currentDelta: function() {	294	currentDelta: function() {
	229	return([	295	return([
	230	parseInt(this.element.~~style~~.~~left~~ \|\| '0'),	296	parseInt(Element.getStyle(this.element,'left') \|\| '0'),
	231	parseInt(this.element.~~style~~.~~top~~ \|\| '0')]);	297	parseInt(Element.getStyle(this.element,'top') \|\| '0')]);
	232	},	298	},
	233		299
	234	initDrag: function(event) {	300	initDrag: function(event) {
			301	if(typeof Draggable._dragging[this.element] != 'undefined' &&
			302	Draggable._dragging[this.element]) return;
	235	if(Event.isLeftClick(event)) {	303	if(Event.isLeftClick(event)) {
	236	// abort on form elements, fixes a Firefox issue	304	// abort on form elements, fixes a Firefox issue
	237	var src = Event.element(event);	305	var src = Event.element(event);
	238	if(src.tagName && (	306	if(src.tagName && (
	239	src.tagName=='INPUT' \|\|	307	src.tagName=='INPUT' \|\|
	240	src.tagName=='SELECT' \|\|	308	src.tagName=='SELECT' \|\|
			309	src.tagName=='OPTION' \|\|
	241	src.tagName=='BUTTON' \|\|	310	src.tagName=='BUTTON' \|\|
	242	src.tagName=='TEXTAREA')) return;	311	src.tagName=='TEXTAREA')) return;
	243		312
	244	if(this.element._revert) {
	245	this.element._revert.cancel();
	246	this.element._revert = null;
	247	}
	248
	249	var pointer = [Event.pointerX(event), Event.pointerY(event)];	313	var pointer = [Event.pointerX(event), Event.pointerY(event)];
	250	var pos = Position.cumulativeOffset(this.element);	314	var pos = Position.cumulativeOffset(this.element);
	251	this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });	315	this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });
	@@ -269,7 +333,19 Draggable.prototype = {
	269	this.element.parentNode.insertBefore(this._clone, this.element);	333	this.element.parentNode.insertBefore(this._clone, this.element);
	270	}	334	}
	271		335
			336	if(this.options.scroll) {
			337	if (this.options.scroll == window) {
			338	var where = this._getWindowScroll(this.options.scroll);
			339	this.originalScrollLeft = where.left;
			340	this.originalScrollTop = where.top;
			341	} else {
			342	this.originalScrollLeft = this.options.scroll.scrollLeft;
			343	this.originalScrollTop = this.options.scroll.scrollTop;
			344	}
			345	}
			346
	272	Draggables.notify('onStart', this, event);	347	Draggables.notify('onStart', this, event);
			348
	273	if(this.options.starteffect) this.options.starteffect(this.element);	349	if(this.options.starteffect) this.options.starteffect(this.element);
	274	},	350	},
	275		351
	@@ -278,11 +354,34 Draggable.prototype = {
	278	Position.prepare();	354	Position.prepare();
	279	Droppables.show(pointer, this.element);	355	Droppables.show(pointer, this.element);
	280	Draggables.notify('onDrag', this, event);	356	Draggables.notify('onDrag', this, event);
			357
	281	this.draw(pointer);	358	this.draw(pointer);
	282	if(this.options.change) this.options.change(this);	359	if(this.options.change) this.options.change(this);
	283		360
			361	if(this.options.scroll) {
			362	this.stopScrolling();
			363
			364	var p;
			365	if (this.options.scroll == window) {
			366	with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
			367	} else {
			368	p = Position.page(this.options.scroll);
			369	p[0] += this.options.scroll.scrollLeft + Position.deltaX;
			370	p[1] += this.options.scroll.scrollTop + Position.deltaY;
			371	p.push(p[0]+this.options.scroll.offsetWidth);
			372	p.push(p[1]+this.options.scroll.offsetHeight);
			373	}
			374	var speed = [0,0];
			375	if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
			376	if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
			377	if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
			378	if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
			379	this.startScrolling(speed);
			380	}
			381
	284	// fix AppleWebKit rendering	382	// fix AppleWebKit rendering
	285	if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);	383	if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
			384
	286	Event.stop(event);	385	Event.stop(event);
	287	},	386	},
	288		387
	@@ -314,33 +413,46 Draggable.prototype = {
	314		413
	315	if(this.options.endeffect)	414	if(this.options.endeffect)
	316	this.options.endeffect(this.element);	415	this.options.endeffect(this.element);
	317		416
	318	Draggables.deactivate(this);	417	Draggables.deactivate(this);
	319	Droppables.reset();	418	Droppables.reset();
	320	},	419	},
	321		420
	322	keyPress: function(event) {	421	keyPress: function(event) {
	323	if(!event.keyCode==Event.KEY_ESC) return;	422	if(event.keyCode!=Event.KEY_ESC) return;
	324	this.finishDrag(event, false);	423	this.finishDrag(event, false);
	325	Event.stop(event);	424	Event.stop(event);
	326	},	425	},
	327		426
	328	endDrag: function(event) {	427	endDrag: function(event) {
	329	if(!this.dragging) return;	428	if(!this.dragging) return;
			429	this.stopScrolling();
	330	this.finishDrag(event, true);	430	this.finishDrag(event, true);
	331	Event.stop(event);	431	Event.stop(event);
	332	},	432	},
	333		433
	334	draw: function(point) {	434	draw: function(point) {
	335	var pos = Position.cumulativeOffset(this.element);	435	var pos = Position.cumulativeOffset(this.element);
			436	if(this.options.ghosting) {
			437	var r = Position.realOffset(this.element);
			438	pos[0] += r[0] - Position.deltaX; pos[1] += r[1] - Position.deltaY;
			439	}
			440
	336	var d = this.currentDelta();	441	var d = this.currentDelta();
	337	pos[0] -= d[0]; pos[1] -= d[1];	442	pos[0] -= d[0]; pos[1] -= d[1];
	338		443
	339	var p = [0,1].map(function(i){ return (point[i]-pos[i]-this.offset[i]) }.bind(this));	444	if(this.options.scroll && (this.options.scroll != window && this._isScrollChild)) {
			445	pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
			446	pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
			447	}
			448
			449	var p = [0,1].map(function(i){
			450	return (point[i]-pos[i]-this.offset[i])
			451	}.bind(this));
	340		452
	341	if(this.options.snap) {	453	if(this.options.snap) {
	342	if(typeof this.options.snap == 'function') {	454	if(typeof this.options.snap == 'function') {
	343	p = this.options.snap(p[0],p[1]);	455	p = this.options.snap(p[0],p[1],this);
	344	} else {	456	} else {
	345	if(this.options.snap instanceof Array) {	457	if(this.options.snap instanceof Array) {
	346	p = p.map( function(v, i) {	458	p = p.map( function(v, i) {
	@@ -356,7 +468,80 Draggable.prototype = {
	356	style.left = p[0] + "px";	468	style.left = p[0] + "px";
	357	if((!this.options.constraint) \|\| (this.options.constraint=='vertical'))	469	if((!this.options.constraint) \|\| (this.options.constraint=='vertical'))
	358	style.top = p[1] + "px";	470	style.top = p[1] + "px";
			471
	359	if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering	472	if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
			473	},
			474
			475	stopScrolling: function() {
			476	if(this.scrollInterval) {
			477	clearInterval(this.scrollInterval);
			478	this.scrollInterval = null;
			479	Draggables._lastScrollPointer = null;
			480	}
			481	},
			482
			483	startScrolling: function(speed) {
			484	if(!(speed[0] \|\| speed[1])) return;
			485	this.scrollSpeed = [speed[0]this.options.scrollSpeed,speed[1]this.options.scrollSpeed];
			486	this.lastScrolled = new Date();
			487	this.scrollInterval = setInterval(this.scroll.bind(this), 10);
			488	},
			489
			490	scroll: function() {
			491	var current = new Date();
			492	var delta = current - this.lastScrolled;
			493	this.lastScrolled = current;
			494	if(this.options.scroll == window) {
			495	with (this._getWindowScroll(this.options.scroll)) {
			496	if (this.scrollSpeed[0] \|\| this.scrollSpeed[1]) {
			497	var d = delta / 1000;
			498	this.options.scroll.scrollTo( left + dthis.scrollSpeed[0], top + dthis.scrollSpeed[1] );
			499	}
			500	}
			501	} else {
			502	this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
			503	this.options.scroll.scrollTop += this.scrollSpeed[1] * delta / 1000;
			504	}
			505
			506	Position.prepare();
			507	Droppables.show(Draggables._lastPointer, this.element);
			508	Draggables.notify('onDrag', this);
			509	if (this._isScrollChild) {
			510	Draggables._lastScrollPointer = Draggables._lastScrollPointer \|\| $A(Draggables._lastPointer);
			511	Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
			512	Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
			513	if (Draggables._lastScrollPointer[0] < 0)
			514	Draggables._lastScrollPointer[0] = 0;
			515	if (Draggables._lastScrollPointer[1] < 0)
			516	Draggables._lastScrollPointer[1] = 0;
			517	this.draw(Draggables._lastScrollPointer);
			518	}
			519
			520	if(this.options.change) this.options.change(this);
			521	},
			522
			523	_getWindowScroll: function(w) {
			524	var T, L, W, H;
			525	with (w.document) {
			526	if (w.document.documentElement && documentElement.scrollTop) {
			527	T = documentElement.scrollTop;
			528	L = documentElement.scrollLeft;
			529	} else if (w.document.body) {
			530	T = body.scrollTop;
			531	L = body.scrollLeft;
			532	}
			533	if (w.innerWidth) {
			534	W = w.innerWidth;
			535	H = w.innerHeight;
			536	} else if (w.document.documentElement && documentElement.clientWidth) {
			537	W = documentElement.clientWidth;
			538	H = documentElement.clientHeight;
			539	} else {
			540	W = body.offsetWidth;
			541	H = body.offsetHeight
			542	}
			543	}
			544	return { top: T, left: L, width: W, height: H };
	360	}	545	}
	361	}	546	}
	362		547
	@@ -382,38 +567,55 SortableObserver.prototype = {
	382	}	567	}
	383		568
	384	var Sortable = {	569	var Sortable = {
	385	sortables: new Array(),	570	SERIALIZE_RULE: /^[^_\-](?:[A-Za-z0-9\-\_])[_](.)$/,
	386		571
	387	options: function(element){	572	sortables: {},
	388	element = $(element);	573
	389	return this.sortables.detect(function(s) { return s.element == element });	574	_findRootElement: function(element) {
			575	while (element.tagName != "BODY") {
			576	if(element.id && Sortable.sortables[element.id]) return element;
			577	element = element.parentNode;
			578	}
			579	},
			580
			581	options: function(element) {
			582	element = Sortable._findRootElement($(element));
			583	if(!element) return;
			584	return Sortable.sortables[element.id];
	390	},	585	},
	391		586
	392	destroy: function(element){	587	destroy: function(element){
	393	element = $(element);	588	var s = Sortable.options(element);
	394	this.sortables.findAll(function(s) { return s.element == element }).each(function(s){	589
			590	if(s) {
	395	Draggables.removeObserver(s.element);	591	Draggables.removeObserver(s.element);
	396	s.droppables.each(function(d){ Droppables.remove(d) });	592	s.droppables.each(function(d){ Droppables.remove(d) });
	397	s.draggables.invoke('destroy');	593	s.draggables.invoke('destroy');
	398	~~});~~	594
	399	this.sortables = this.sortables.reject(function(s) { return s.element == element });	595	delete Sortable.sortables[s.element.id];
			596	}
	400	},	597	},
	401		598
	402	create: function(element) {	599	create: function(element) {
	403	element = $(element);	600	element = $(element);
	404	var options = Object.extend({	601	var options = Object.extend({
	405	element: element,	602	element: element,
	406	tag: 'li', // assumes li children, override with tag: 'tagname'	603	tag: 'li', // assumes li children, override with tag: 'tagname'
	407	dropOnEmpty: false,	604	dropOnEmpty: false,
	408	tree: false, ~~// fixme: unimplemented~~	605	tree: false,
			606	treeTag: 'ul',
	409	overlap: 'vertical', // one of 'vertical', 'horizontal'	607	overlap: 'vertical', // one of 'vertical', 'horizontal'
	410	constraint: 'vertical', // one of 'vertical', 'horizontal', false	608	constraint: 'vertical', // one of 'vertical', 'horizontal', false
	411	containment: element, // also takes array of elements (or id's); or false	609	containment: element, // also takes array of elements (or id's); or false
	412	handle: false, // or a CSS class	610	handle: false, // or a CSS class
	413	only: false,	611	only: false,
			612	delay: 0,
	414	hoverclass: null,	613	hoverclass: null,
	415	ghosting: false,	614	ghosting: false,
	416	format: null,	615	scroll: false,
			616	scrollSensitivity: 20,
			617	scrollSpeed: 15,
			618	format: this.SERIALIZE_RULE,
	417	onChange: Prototype.emptyFunction,	619	onChange: Prototype.emptyFunction,
	418	onUpdate: Prototype.emptyFunction	620	onUpdate: Prototype.emptyFunction
	419	}, arguments[1] \|\| {});	621	}, arguments[1] \|\| {});
	@@ -424,6 +626,10 var Sortable = {
	424	// build options for the draggables	626	// build options for the draggables
	425	var options_for_draggable = {	627	var options_for_draggable = {
	426	revert: true,	628	revert: true,
			629	scroll: options.scroll,
			630	scrollSpeed: options.scrollSpeed,
			631	scrollSensitivity: options.scrollSensitivity,
			632	delay: options.delay,
	427	ghosting: options.ghosting,	633	ghosting: options.ghosting,
	428	constraint: options.constraint,	634	constraint: options.constraint,
	429	handle: options.handle };	635	handle: options.handle };
	@@ -449,9 +655,16 var Sortable = {
	449	var options_for_droppable = {	655	var options_for_droppable = {
	450	overlap: options.overlap,	656	overlap: options.overlap,
	451	containment: options.containment,	657	containment: options.containment,
			658	tree: options.tree,
	452	hoverclass: options.hoverclass,	659	hoverclass: options.hoverclass,
	453	onHover: Sortable.onHover,	660	onHover: Sortable.onHover
	454	greedy: !options.dropOnEmpty	661	}
			662
			663	var options_for_tree = {
			664	onHover: Sortable.onEmptyHover,
			665	overlap: options.overlap,
			666	containment: options.containment,
			667	hoverclass: options.hoverclass
	455	}	668	}
	456		669
	457	// fix for gecko engine	670	// fix for gecko engine
	@@ -460,27 +673,33 var Sortable = {
	460	options.draggables = [];	673	options.draggables = [];
	461	options.droppables = [];	674	options.droppables = [];
	462		675
	463	// make it so
	464
	465	// drop on empty handling	676	// drop on empty handling
	466	if(options.dropOnEmpty) {	677	if(options.dropOnEmpty \|\| options.tree) {
	467	Droppables.add(element,	678	Droppables.add(element, options_for_tree);
	468	{containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false});
	469	options.droppables.push(element);	679	options.droppables.push(element);
	470	}	680	}
	471		681
	472	(this.findElements(element, options) \|\| []).each( function(e) {	682	(this.findElements(element, options) \|\| []).each( function(e) {
	473	// handles are per-draggable	683	// handles are per-draggable
	474	var handle = options.handle ?	684	var handle = options.handle ?
	475	Element.childrenWithClassName(e, options.handle)[0] : e;	685	$(e).down('.'+options.handle,0) : e;
	476	options.draggables.push(	686	options.draggables.push(
	477	new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));	687	new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
	478	Droppables.add(e, options_for_droppable);	688	Droppables.add(e, options_for_droppable);
			689	if(options.tree) e.treeNode = element;
	479	options.droppables.push(e);	690	options.droppables.push(e);
	480	});	691	});
			692
			693	if(options.tree) {
			694	(Sortable.findTreeElements(element, options) \|\| []).each( function(e) {
			695	Droppables.add(e, options_for_tree);
			696	e.treeNode = element;
			697	options.droppables.push(e);
			698	});
			699	}
	481		700
	482	// keep reference	701	// keep reference
	483	this.sortables.~~push~~(options);	702	this.sortables[element.id] = options;
	484		703
	485	// for onupdate	704	// for onupdate
	486	Draggables.addObserver(new SortableObserver(element, options.onUpdate));	705	Draggables.addObserver(new SortableObserver(element, options.onUpdate));
	@@ -489,23 +708,21 var Sortable = {
	489		708
	490	// return all suitable-for-sortable elements in a guaranteed order	709	// return all suitable-for-sortable elements in a guaranteed order
	491	findElements: function(element, options) {	710	findElements: function(element, options) {
	492	if(!element.hasChildNodes()) return null;	711	return Element.findChildren(
	493	var elements = [];	712	element, options.only, options.tree ? true : false, options.tag);
	494	$A(element.childNodes).each( function(e) {	713	},
	495	if(e.tagName && e.tagName.toUpperCase()==options.tag.toUpperCase() &&	714
	496	(!options.only \|\| (Element.hasClassName(e, options.only))))	715	findTreeElements: function(element, options) {
	497	elements.push(e);	716	return Element.findChildren(
	498	if(options.tree) {	717	element, options.only, options.tree ? true : false, options.treeTag);
	499	var grandchildren = this.findElements(e, options);
	500	if(grandchildren) elements.push(grandchildren);
	501	}
	502	});
	503
	504	return (elements.length>0 ? elements.flatten() : null);
	505	},	718	},
	506		719
	507	onHover: function(element, dropon, overlap) {	720	onHover: function(element, dropon, overlap) {
	508	if(overlap>0.5) {	721	if(Element.isParent(dropon, element)) return;
			722
			723	if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
			724	return;
			725	} else if(overlap>0.5) {
	509	Sortable.mark(dropon, 'before');	726	Sortable.mark(dropon, 'before');
	510	if(dropon.previousSibling != element) {	727	if(dropon.previousSibling != element) {
	511	var oldParentNode = element.parentNode;	728	var oldParentNode = element.parentNode;
	@@ -528,18 +745,42 var Sortable = {
	528	}	745	}
	529	}	746	}
	530	},	747	},
	531		748
	532	onEmptyHover: function(element, dropon) {	749	onEmptyHover: function(element, dropon, overlap) {
	533	if(element.parentNode!=dropon) {	750	var oldParentNode = element.parentNode;
	534	var oldParentNode = element.parentNode;	751	var droponOptions = Sortable.options(dropon);
	535	dropon.appendChild(element);	752
			753	if(!Element.isParent(dropon, element)) {
			754	var index;
			755
			756	var children = Sortable.findElements(dropon, {tag: droponOptions.tag, only: droponOptions.only});
			757	var child = null;
			758
			759	if(children) {
			760	var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
			761
			762	for (index = 0; index < children.length; index += 1) {
			763	if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
			764	offset -= Element.offsetSize (children[index], droponOptions.overlap);
			765	} else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
			766	child = index + 1 < children.length ? children[index + 1] : null;
			767	break;
			768	} else {
			769	child = children[index];
			770	break;
			771	}
			772	}
			773	}
			774
			775	dropon.insertBefore(element, child);
			776
	536	Sortable.options(oldParentNode).onChange(element);	777	Sortable.options(oldParentNode).onChange(element);
	537	~~Sortable~~.~~options~~(~~dropon~~).onChange(element);	778	droponOptions.onChange(element);
	538	}	779	}
	539	},	780	},
	540		781
	541	unmark: function() {	782	unmark: function() {
	542	if(Sortable._marker) ~~Element~~.hide(~~Sortable~~.~~_marker~~);	783	if(Sortable._marker) Sortable._marker.hide();
	543	},	784	},
	544		785
	545	mark: function(dropon, position) {	786	mark: function(dropon, position) {
	@@ -548,37 +789,154 var Sortable = {
	548	if(sortable && !sortable.ghosting) return;	789	if(sortable && !sortable.ghosting) return;
	549		790
	550	if(!Sortable._marker) {	791	if(!Sortable._marker) {
	551	Sortable._marker = $('dropmarker') \|\| document.createElement('DIV');	792	Sortable._marker =
	552	Element.hide(Sortable._marker);	793	($('dropmarker') \|\| Element.extend(document.createElement('DIV'))).
	553	Element.addClassName(Sortable._marker, 'dropmarker');	794	hide().addClassName('dropmarker').setStyle({position:'absolute'});
	554	Sortable._marker.style.position = 'absolute';
	555	document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);	795	document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
	556	}	796	}
	557	var offsets = Position.cumulativeOffset(dropon);	797	var offsets = Position.cumulativeOffset(dropon);
	558	Sortable._marker.s~~tyle~~.left = offsets[0] + 'px';	798	Sortable._marker.setStyle({left: offsets[0]+'px', top: offsets[1] + 'px'});
	559	Sortable._marker.style.top = offsets[1] + 'px';
	560		799
	561	if(position=='after')	800	if(position=='after')
	562	if(sortable.overlap == 'horizontal')	801	if(sortable.overlap == 'horizontal')
	563	Sortable._marker.s~~tyle~~.left = (offsets[0]+dropon.clientWidth) + 'px';	802	Sortable._marker.setStyle({left: (offsets[0]+dropon.clientWidth) + 'px'});
	564	else	803	else
	565	Sortable._marker.s~~tyle~~.top = (offsets[1]+dropon.clientHeight) + 'px';	804	Sortable._marker.setStyle({top: (offsets[1]+dropon.clientHeight) + 'px'});
	566		805
	567	~~Element~~.show(~~Sortable~~.~~_marker~~);	806	Sortable._marker.show();
	568	},	807	},
			808
			809	_tree: function(element, options, parent) {
			810	var children = Sortable.findElements(element, options) \|\| [];
			811
			812	for (var i = 0; i < children.length; ++i) {
			813	var match = children[i].id.match(options.format);
	569		814
	570	serialize: function(element) {	815	if (!match) continue;
			816
			817	var child = {
			818	id: encodeURIComponent(match ? match[1] : null),
			819	element: element,
			820	parent: parent,
			821	children: [],
			822	position: parent.children.length,
			823	container: $(children[i]).down(options.treeTag)
			824	}
			825
			826	/* Get the element containing the children and recurse over it */
			827	if (child.container)
			828	this._tree(child.container, options, child)
			829
			830	parent.children.push (child);
			831	}
			832
			833	return parent;
			834	},
			835
			836	tree: function(element) {
	571	element = $(element);	837	element = $(element);
	572	var sortableOptions = this.options(element);	838	var sortableOptions = this.options(element);
	573	var options = Object.extend({	839	var options = Object.extend({
	574	tag: sortableOptions.tag,	840	tag: sortableOptions.tag,
			841	treeTag: sortableOptions.treeTag,
	575	only: sortableOptions.only,	842	only: sortableOptions.only,
	576	name: element.id,	843	name: element.id,
	577	format: sortableOptions.format \|\| ~~/^[^_]_(.)$/~~	844	format: sortableOptions.format
	578	}, arguments[1] \|\| {});	845	}, arguments[1] \|\| {});
			846
			847	var root = {
			848	id: null,
			849	parent: null,
			850	children: [],
			851	container: element,
			852	position: 0
			853	}
			854
			855	return Sortable._tree(element, options, root);
			856	},
			857
			858	/* Construct a [i] index for a particular node */
			859	_constructIndex: function(node) {
			860	var index = '';
			861	do {
			862	if (node.id) index = '[' + node.position + ']' + index;
			863	} while ((node = node.parent) != null);
			864	return index;
			865	},
			866
			867	sequence: function(element) {
			868	element = $(element);
			869	var options = Object.extend(this.options(element), arguments[1] \|\| {});
			870
	579	return $(this.findElements(element, options) \|\| []).map( function(item) {	871	return $(this.findElements(element, options) \|\| []).map( function(item) {
	580	return (encodeURIComponent(options.name) + "[]=" +	872	return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
	581	encodeURIComponent(item.id.match(options.format) ? item.id.match(options.format)[1] : ''));	873	});
	582	}).join("&");	874	},
			875
			876	setSequence: function(element, new_sequence) {
			877	element = $(element);
			878	var options = Object.extend(this.options(element), arguments[2] \|\| {});
			879
			880	var nodeMap = {};
			881	this.findElements(element, options).each( function(n) {
			882	if (n.id.match(options.format))
			883	nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
			884	n.parentNode.removeChild(n);
			885	});
			886
			887	new_sequence.each(function(ident) {
			888	var n = nodeMap[ident];
			889	if (n) {
			890	n[1].appendChild(n[0]);
			891	delete nodeMap[ident];
			892	}
			893	});
			894	},
			895
			896	serialize: function(element) {
			897	element = $(element);
			898	var options = Object.extend(Sortable.options(element), arguments[1] \|\| {});
			899	var name = encodeURIComponent(
			900	(arguments[1] && arguments[1].name) ? arguments[1].name : element.id);
			901
			902	if (options.tree) {
			903	return Sortable.tree(element, arguments[1]).children.map( function (item) {
			904	return [name + Sortable._constructIndex(item) + "[id]=" +
			905	encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
			906	}).flatten().join('&');
			907	} else {
			908	return Sortable.sequence(element, arguments[1]).map( function(item) {
			909	return name + "[]=" + encodeURIComponent(item);
			910	}).join('&');
			911	}
	583	}	912	}
	584	} No newline at end of file	913	}
			914
			915	// Returns true if child is contained within element
			916	Element.isParent = function(child, element) {
			917	if (!child.parentNode \|\| child == element) return false;
			918	if (child.parentNode == element) return true;
			919	return Element.isParent(child.parentNode, element);
			920	}
			921
			922	Element.findChildren = function(element, only, recursive, tagName) {
			923	if(!element.hasChildNodes()) return null;
			924	tagName = tagName.toUpperCase();
			925	if(only) only = [only].flatten();
			926	var elements = [];
			927	$A(element.childNodes).each( function(e) {
			928	if(e.tagName && e.tagName.toUpperCase()==tagName &&
			929	(!only \|\| (Element.classNames(e).detect(function(v) { return only.include(v) }))))
			930	elements.push(e);
			931	if(recursive) {
			932	var grandchildren = Element.findChildren(e, only, recursive, tagName);
			933	if(grandchildren) elements.push(grandchildren);
			934	}
			935	});
			936
			937	return (elements.length>0 ? elements.flatten() : []);
			938	}
			939
			940	Element.offsetSize = function (element, type) {
			941	return element['offset' + ((type=='vertical' \|\| type=='height') ? 'Height' : 'Width')];
			942	}

public/javascripts/effects.js +517 -283

This diff has been collapsed as it changes many lines, (800 lines changed) Show them Hide them
	@@ -1,17 +1,16
	1	// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)	1	// Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
	2	// Contributors:	2	// Contributors:
	3	// Justin Palmer (http://encytemedia.com/)	3	// Justin Palmer (http://encytemedia.com/)
	4	// Mark Pilgrim (http://diveintomark.org/)	4	// Mark Pilgrim (http://diveintomark.org/)
	5	// Martin Bialasinki	5	// Martin Bialasinki
	6	//	6	//
	7	// See scriptaculous.js for full license.	7	// script.aculo.us is freely distributable under the terms of an MIT-style license.
			8	// For details, see the script.aculo.us web site: http://script.aculo.us/
	8		9
	9	/* ------------- element ext -------------- */
	10
	11	// converts rgb() and #xxx to #xxxxxx format,	10	// converts rgb() and #xxx to #xxxxxx format,
	12	// returns self (or first argument) if not convertable	11	// returns self (or first argument) if not convertable
	13	String.prototype.parseColor = function() {	12	String.prototype.parseColor = function() {
	14	var color = '#';	13	var color = '#';
	15	if(this.slice(0,4) == 'rgb(') {	14	if(this.slice(0,4) == 'rgb(') {
	16	var cols = this.slice(4,this.length-1).split(',');	15	var cols = this.slice(4,this.length-1).split(',');
	17	var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);	16	var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);
	@@ -22,40 +21,38 String.prototype.parseColor = function() {
	22	}	21	}
	23	}	22	}
	24	return(color.length==7 ? color : (arguments[0] \|\| this));	23	return(color.length==7 ? color : (arguments[0] \|\| this));
	25	}	24	}
	26		25
	27	Element.collectTextNodesIgnoreClass = function(element, ignoreclass) {	26	/--------------------------------------------------------------------------/
	28	var children = $(element).childNodes;	27
	29	var text = '';	28	Element.collectTextNodes = function(element) {
	30	var classtest = new RegExp('^([^ ]+ )' + ignoreclass+ '( [^ ]+)$','i');	29	return $A($(element).childNodes).collect( function(node) {
	31		30	return (node.nodeType==3 ? node.nodeValue :
	32	for (var i = 0; i < children.length; i++) {	31	(node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
	33	if(children[i].nodeType==3) {	32	}).flatten().join('');
	34	text+=children[i].nodeValue;
	35	} else {
	36	if((!children[i].className.match(classtest)) && children[i].hasChildNodes())
	37	text += Element.collectTextNodesIgnoreClass(children[i], ignoreclass);
	38	}
	39	}
	40
	41	return text;
	42	}	33	}
	43		34
	44	Element.~~setStyle~~ = function(element, ~~styl~~e) {	35	Element.collectTextNodesIgnoreClass = function(element, className) {
	45	element = $(element);	36	return $A($(element).childNodes).collect( function(node) {
	46	for(k in style) element.style[k.camelize()] = style[k];	37	return (node.nodeType==3 ? node.nodeValue :
			38	((node.hasChildNodes() && !Element.hasClassName(node,className)) ?
			39	Element.collectTextNodesIgnoreClass(node, className) : ''));
			40	}).flatten().join('');
	47	}	41	}
	48		42
	49	Element.setContentZoom = function(element, percent) {	43	Element.setContentZoom = function(element, percent) {
	50	Element.setStyle(element, {fontSize: (percent/100) + 'em'});	44	element = $(element);
	51	if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);	45	element.setStyle({fontSize: (percent/100) + 'em'});
			46	if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
			47	return element;
	52	}	48	}
	53		49
	54	Element.getOpacity = function(element){	50	Element.getOpacity = function(element){
			51	element = $(element);
	55	var opacity;	52	var opacity;
	56	if (opacity = Element.getStyle(~~element~~, 'opacity'))	53	if (opacity = element.getStyle('opacity'))
	57	return parseFloat(opacity);	54	return parseFloat(opacity);
	58	if (opacity = (Element.getStyle(~~element~~, 'filter') \|\| '').match(/alpha$opacity=(.*)$/))	55	if (opacity = (element.getStyle('filter') \|\| '').match(/alpha$opacity=(.*)$/))
	59	if(opacity[1]) return parseFloat(opacity[1]) / 100;	56	if(opacity[1]) return parseFloat(opacity[1]) / 100;
	60	return 1.0;	57	return 1.0;
	61	}	58	}
	@@ -63,29 +60,36 Element.getOpacity = function(element){
	63	Element.setOpacity = function(element, value){	60	Element.setOpacity = function(element, value){
	64	element= $(element);	61	element= $(element);
	65	if (value == 1){	62	if (value == 1){
	66	Element.setStyle(~~element~~, { opacity:	63	element.setStyle({ opacity:
	67	(/Gecko/.test(navigator.userAgent) && !/Konqueror\|Safari\|KHTML/.test(navigator.userAgent)) ?	64	(/Gecko/.test(navigator.userAgent) && !/Konqueror\|Safari\|KHTML/.test(navigator.userAgent)) ?
	68	0.999999 : ~~null~~ });	65	0.999999 : 1.0 });
	69	if(/MSIE/.test(navigator.userAgent))	66	if(/MSIE/.test(navigator.userAgent) && !window.opera)
	70	Element.setStyle(~~element~~, {filter: Element.getStyle(element,'filter').replace(/alpha$[^$]*\)/gi,'')});	67	element.setStyle({filter: Element.getStyle(element,'filter').replace(/alpha$[^$]*\)/gi,'')});
	71	} else {	68	} else {
	72	if(value < 0.00001) value = 0;	69	if(value < 0.00001) value = 0;
	73	Element.setStyle(~~element~~, {opacity: value});	70	element.setStyle({opacity: value});
	74	if(/MSIE/.test(navigator.userAgent))	71	if(/MSIE/.test(navigator.userAgent) && !window.opera)
	75	Element.setStyle(~~element~~,	72	element.setStyle(
	76	{ filter: Element.getStyle(~~element~~,'filter').replace(/alpha$[^$]*\)/gi,'') +	73	{ filter: element.getStyle('filter').replace(/alpha$[^$]*\)/gi,'') +
	77	'alpha(opacity='+value*100+')' });	74	'alpha(opacity='+value*100+')' });
	78	}	75	}
			76	return element;
	79	}	77	}
	80		78
	81	Element.getInlineOpacity = function(element){	79	Element.getInlineOpacity = function(element){
	82	return $(element).style.opacity \|\| '';	80	return $(element).style.opacity \|\| '';
	83	}	81	}
	84		82
	85	Element.~~childrenWithClassName~~ = function(element, ~~className~~) {	83	Element.forceRerendering = function(element) {
	86	return $A($(element).getElementsByTagName('*')).select(	84	try {
	87	function(c) { return Element.hasClassName(c, className) });	85	element = $(element);
	88	}	86	var n = document.createTextNode(' ');
			87	element.appendChild(n);
			88	element.removeChild(n);
			89	} catch(e) { }
			90	};
			91
			92	/--------------------------------------------------------------------------/
	89		93
	90	Array.prototype.call = function() {	94	Array.prototype.call = function() {
	91	var args = arguments;	95	var args = arguments;
	@@ -95,9 +99,17 Array.prototype.call = function() {
	95	/--------------------------------------------------------------------------/	99	/--------------------------------------------------------------------------/
	96		100
	97	var Effect = {	101	var Effect = {
			102	_elementDoesNotExistError: {
			103	name: 'ElementDoesNotExistError',
			104	message: 'The specified DOM element does not exist, but is required for this effect to operate'
			105	},
	98	tagifyText: function(element) {	106	tagifyText: function(element) {
			107	if(typeof Builder == 'undefined')
			108	throw("Effect.tagifyText requires including script.aculo.us' builder.js library");
			109
	99	var tagifyStyle = 'position:relative';	110	var tagifyStyle = 'position:relative';
	100	if(/MSIE/.test(navigator.userAgent)) tagifyStyle += ';zoom:1';	111	if(/MSIE/.test(navigator.userAgent) && !window.opera) tagifyStyle += ';zoom:1';
			112
	101	element = $(element);	113	element = $(element);
	102	$A(element.childNodes).each( function(child) {	114	$A(element.childNodes).each( function(child) {
	103	if(child.nodeType==3) {	115	if(child.nodeType==3) {
	@@ -129,6 +141,20 var Effect = {
	129	$A(elements).each( function(element, index) {	141	$A(elements).each( function(element, index) {
	130	new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));	142	new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
	131	});	143	});
			144	},
			145	PAIRS: {
			146	'slide': ['SlideDown','SlideUp'],
			147	'blind': ['BlindDown','BlindUp'],
			148	'appear': ['Appear','Fade']
			149	},
			150	toggle: function(element, effect) {
			151	element = $(element);
			152	effect = (effect \|\| 'appear').toLowerCase();
			153	var options = Object.extend({
			154	queue: { position:'end', scope:(element.id \|\| 'global'), limit: 1 }
			155	}, arguments[2] \|\| {});
			156	Effect[element.visible() ?
			157	Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
	132	}	158	}
	133	};	159	};
	134		160
	@@ -136,46 +162,54 var Effect2 = Effect; // deprecated
	136		162
	137	/* ------------- transitions ------------- */	163	/* ------------- transitions ------------- */
	138		164
	139	Effect.Transitions = {}	165	Effect.Transitions = {
	140		166	linear: Prototype.K,
	141	Effect.Transitions.linear = function(pos) {	167	sinoidal: function(pos) {
	142	return pos;	168	return (-Math.cos(pos*Math.PI)/2) + 0.5;
	143	}	169	},
	144	Effect.Transitions.sinoidal = function(pos) {	170	reverse: function(pos) {
	145	return (-Math.cos(pos*Math.PI)/2) + 0.5;	171	return 1-pos;
	146	}	172	},
	147	Effect.Transitions.reverse = function(pos) {	173	flicker: function(pos) {
	148	return 1-pos;	174	return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
	149	}	175	},
	150	Effect.Transitions.flicker = function(pos) {	176	wobble: function(pos) {
	151	return ((-Math.cos(pos*Math.PI)/4) + 0.75) + ~~Math~~.~~random~~()/4;	177	return (-Math.cos(posMath.PI(9*pos))/2) + 0.5;
	152	}	178	},
	153	Effect.Transitions.wobble = function(pos) {	179	pulse: function(pos, pulses) {
	154	return (-Math.cos(posMath.PI(9*pos))/2) + 0.5;	180	pulses = pulses \|\| 5;
	155	}	181	return (
	156	Effect.Transitions.pulse = function(pos) {	182	Math.round((pos % (1/pulses)) * pulses) == 0 ?
	157	return (Math.floor(pos*10) % 2 == 0 ?	183	((pos * pulses * 2) - Math.floor(pos * pulses * 2)) :
	158	(pos10-Math.floor(pos10)) : 1-(pos10-Math.floor(pos10)));	184	1 - ((pos * pulses * 2) - Math.floor(pos * pulses * 2))
	159	}	185	);
	160	Effect.Transitions.none = function(pos) {	186	},
	161	return 0;	187	none: function(pos) {
	162	}	188	return 0;
	163	Effect.Transitions.full = function(pos) {	189	},
	164	return 1;	190	full: function(pos) {
	165	}	191	return 1;
			192	}
			193	};
	166		194
	167	/* ------------- core effects ------------- */	195	/* ------------- core effects ------------- */
	168		196
	169	Effect.Queue = {	197	Effect.ScopedQueue = Class.create();
	170	effects: [],	198	Object.extend(Object.extend(Effect.ScopedQueue.prototype, Enumerable), {
			199	initialize: function() {
			200	this.effects = [];
			201	this.interval = null;
			202	},
	171	_each: function(iterator) {	203	_each: function(iterator) {
	172	this.effects._each(iterator);	204	this.effects._each(iterator);
	173	},	205	},
	174	interval: null,
	175	add: function(effect) {	206	add: function(effect) {
	176	var timestamp = new Date().getTime();	207	var timestamp = new Date().getTime();
	177		208
	178	~~switch~~(effect.options.queue) {	209	var position = (typeof effect.options.queue == 'string') ?
			210	effect.options.queue : effect.options.queue.position;
			211
			212	switch(position) {
	179	case 'front':	213	case 'front':
	180	// move unstarted effects after this effect	214	// move unstarted effects after this effect
	181	this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {	215	this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
	@@ -183,6 +217,9 Effect.Queue = {
	183	e.finishOn += effect.finishOn;	217	e.finishOn += effect.finishOn;
	184	});	218	});
	185	break;	219	break;
			220	case 'with-last':
			221	timestamp = this.effects.pluck('startOn').max() \|\| timestamp;
			222	break;
	186	case 'end':	223	case 'end':
	187	// start effect after last queued effect has finished	224	// start effect after last queued effect has finished
	188	timestamp = this.effects.pluck('finishOn').max() \|\| timestamp;	225	timestamp = this.effects.pluck('finishOn').max() \|\| timestamp;
	@@ -191,7 +228,10 Effect.Queue = {
	191		228
	192	effect.startOn += timestamp;	229	effect.startOn += timestamp;
	193	effect.finishOn += timestamp;	230	effect.finishOn += timestamp;
	194	this.effects.push(effect);	231
			232	if(!effect.options.queue.limit \|\| (this.effects.length < effect.options.queue.limit))
			233	this.effects.push(effect);
			234
	195	if(!this.interval)	235	if(!this.interval)
	196	this.interval = setInterval(this.loop.bind(this), 40);	236	this.interval = setInterval(this.loop.bind(this), 40);
	197	},	237	},
	@@ -206,32 +246,45 Effect.Queue = {
	206	var timePos = new Date().getTime();	246	var timePos = new Date().getTime();
	207	this.effects.invoke('loop', timePos);	247	this.effects.invoke('loop', timePos);
	208	}	248	}
			249	});
			250
			251	Effect.Queues = {
			252	instances: $H(),
			253	get: function(queueName) {
			254	if(typeof queueName != 'string') return queueName;
			255
			256	if(!this.instances[queueName])
			257	this.instances[queueName] = new Effect.ScopedQueue();
			258
			259	return this.instances[queueName];
			260	}
			261	}
			262	Effect.Queue = Effect.Queues.get('global');
			263
			264	Effect.DefaultOptions = {
			265	transition: Effect.Transitions.sinoidal,
			266	duration: 1.0, // seconds
			267	fps: 25.0, // max. 25fps due to Effect.Queue implementation
			268	sync: false, // true for combining
			269	from: 0.0,
			270	to: 1.0,
			271	delay: 0.0,
			272	queue: 'parallel'
	209	}	273	}
	210	Object.extend(Effect.Queue, Enumerable);
	211		274
	212	Effect.Base = function() {};	275	Effect.Base = function() {};
	213	Effect.Base.prototype = {	276	Effect.Base.prototype = {
	214	position: null,	277	position: null,
	215	setOptions: function(options) {
	216	this.options = Object.extend({
	217	transition: Effect.Transitions.sinoidal,
	218	duration: 1.0, // seconds
	219	fps: 25.0, // max. 25fps due to Effect.Queue implementation
	220	sync: false, // true for combining
	221	from: 0.0,
	222	to: 1.0,
	223	delay: 0.0,
	224	queue: 'parallel'
	225	}, options \|\| {});
	226	},
	227	start: function(options) {	278	start: function(options) {
	228	this.setOptions(options \|\| {});	279	this.options = Object.extend(Object.extend({},Effect.DefaultOptions), options \|\| {});
	229	this.currentFrame = 0;	280	this.currentFrame = 0;
	230	this.state = 'idle';	281	this.state = 'idle';
	231	this.startOn = this.options.delay*1000;	282	this.startOn = this.options.delay*1000;
	232	this.finishOn = this.startOn + (this.options.duration*1000);	283	this.finishOn = this.startOn + (this.options.duration*1000);
	233	this.event('beforeStart');	284	this.event('beforeStart');
	234	if(!this.options.sync) ~~Effect~~.~~Queue~~.~~add~~(~~this~~);	285	if(!this.options.sync)
			286	Effect.Queues.get(typeof this.options.queue == 'string' ?
			287	'global' : this.options.queue.scope).add(this);
	235	},	288	},
	236	loop: function(timePos) {	289	loop: function(timePos) {
	237	if(timePos >= this.startOn) {	290	if(timePos >= this.startOn) {
	@@ -269,7 +322,9 Effect.Base.prototype = {
	269	}	322	}
	270	},	323	},
	271	cancel: function() {	324	cancel: function() {
	272	if(!this.options.sync) ~~Effect~~.~~Queue~~.~~remove~~(~~this~~);	325	if(!this.options.sync)
			326	Effect.Queues.get(typeof this.options.queue == 'string' ?
			327	'global' : this.options.queue.scope).remove(this);
	273	this.state = 'finished';	328	this.state = 'finished';
	274	},	329	},
	275	event: function(eventName) {	330	event: function(eventName) {
	@@ -301,53 +356,81 Object.extend(Object.extend(Effect.Parallel.prototype, Effect.Base.prototype), {
	301	}	356	}
	302	});	357	});
	303		358
			359	Effect.Event = Class.create();
			360	Object.extend(Object.extend(Effect.Event.prototype, Effect.Base.prototype), {
			361	initialize: function() {
			362	var options = Object.extend({
			363	duration: 0
			364	}, arguments[0] \|\| {});
			365	this.start(options);
			366	},
			367	update: Prototype.emptyFunction
			368	});
			369
	304	Effect.Opacity = Class.create();	370	Effect.Opacity = Class.create();
	305	Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype), {	371	Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype), {
	306	initialize: function(element) {	372	initialize: function(element) {
	307	this.element = $(element);	373	this.element = $(element);
			374	if(!this.element) throw(Effect._elementDoesNotExistError);
	308	// make this work on IE on elements without 'layout'	375	// make this work on IE on elements without 'layout'
	309	if(/MSIE/.test(navigator.userAgent) && (!this.element.hasLayout))	376	if(/MSIE/.test(navigator.userAgent) && !window.opera && (!this.element.currentStyle.hasLayout))
	310	Element.setStyle(~~this~~.~~element~~, {zoom: 1});	377	this.element.setStyle({zoom: 1});
	311	var options = Object.extend({	378	var options = Object.extend({
	312	from: Element.getOpacity(~~this~~.~~element~~) \|\| 0.0,	379	from: this.element.getOpacity() \|\| 0.0,
	313	to: 1.0	380	to: 1.0
	314	}, arguments[1] \|\| {});	381	}, arguments[1] \|\| {});
	315	this.start(options);	382	this.start(options);
	316	},	383	},
	317	update: function(position) {	384	update: function(position) {
	318	Element.setOpacity(~~this~~.~~element~~, position);	385	this.element.setOpacity(position);
	319	}	386	}
	320	});	387	});
	321		388
	322	Effect.MoveBy = Class.create();	389	Effect.Move = Class.create();
	323	Object.extend(Object.extend(Effect.MoveBy.prototype, Effect.Base.prototype), {	390	Object.extend(Object.extend(Effect.Move.prototype, Effect.Base.prototype), {
	324	initialize: function(element, ~~toTop~~, ~~toLeft~~) {	391	initialize: function(element) {
	325	this.element = $(element);	392	this.element = $(element);
	326	this.toTop = toTop;	393	if(!this.element) throw(Effect._elementDoesNotExistError);
	327	this.toLeft = toLeft;	394	var options = Object.extend({
	328	this.start(arguments[3]);	395	x: 0,
			396	y: 0,
			397	mode: 'relative'
			398	}, arguments[1] \|\| {});
			399	this.start(options);
	329	},	400	},
	330	setup: function() {	401	setup: function() {
	331	// Bug in Opera: Opera returns the "real" position of a static element or	402	// Bug in Opera: Opera returns the "real" position of a static element or
	332	// relative element that does not have top/left explicitly set.	403	// relative element that does not have top/left explicitly set.
	333	// ==> Always set top and left for position relative elements in your stylesheets	404	// ==> Always set top and left for position relative elements in your stylesheets
	334	// (to 0 if you do not need them)	405	// (to 0 if you do not need them)
	335	Element.makePositioned(~~this~~.~~element~~);	406	this.element.makePositioned();
	336	this.original~~Top~~ = parseFloat(Element.getStyle(~~this~~.~~element~~,~~'top~~') \|\| '0');	407	this.originalLeft = parseFloat(this.element.getStyle('left') \|\| '0');
	337	this.original~~Left~~ = parseFloat(Element.getStyle(~~this~~.~~element~~,'~~lef~~t') \|\| '0');	408	this.originalTop = parseFloat(this.element.getStyle('top') \|\| '0');
			409	if(this.options.mode == 'absolute') {
			410	// absolute movement, so we need to calc deltaX and deltaY
			411	this.options.x = this.options.x - this.originalLeft;
			412	this.options.y = this.options.y - this.originalTop;
			413	}
	338	},	414	},
	339	update: function(position) {	415	update: function(position) {
	340	Element.setStyle(~~this~~.~~element~~, {	416	this.element.setStyle({
	341	top: this.~~toT~~op * position + this.original~~Top~~ + 'px',	417	left: Math.round(this.options.x * position + this.originalLeft) + 'px',
	342	~~lef~~t: this.~~toLeft~~ * position + this.original~~Left~~ + 'px'	418	top: Math.round(this.options.y * position + this.originalTop) + 'px'
	343	});	419	});
	344	}	420	}
	345	});	421	});
	346		422
			423	// for backwards compatibility
			424	Effect.MoveBy = function(element, toTop, toLeft) {
			425	return new Effect.Move(element,
			426	Object.extend({ x: toLeft, y: toTop }, arguments[3] \|\| {}));
			427	};
			428
	347	Effect.Scale = Class.create();	429	Effect.Scale = Class.create();
	348	Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {	430	Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
	349	initialize: function(element, percent) {	431	initialize: function(element, percent) {
	350	this.element = $(element)	432	this.element = $(element);
			433	if(!this.element) throw(Effect._elementDoesNotExistError);
	351	var options = Object.extend({	434	var options = Object.extend({
	352	scaleX: true,	435	scaleX: true,
	353	scaleY: true,	436	scaleY: true,
	@@ -361,7 +444,7 Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
	361	},	444	},
	362	setup: function() {	445	setup: function() {
	363	this.restoreAfterFinish = this.options.restoreAfterFinish \|\| false;	446	this.restoreAfterFinish = this.options.restoreAfterFinish \|\| false;
	364	this.elementPositioning = Element.getStyle(~~this~~.~~element~~,'position');	447	this.elementPositioning = this.element.getStyle('position');
	365		448
	366	this.originalStyle = {};	449	this.originalStyle = {};
	367	['top','left','width','height','fontSize'].each( function(k) {	450	['top','left','width','height','fontSize'].each( function(k) {
	@@ -371,8 +454,8 Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
	371	this.originalTop = this.element.offsetTop;	454	this.originalTop = this.element.offsetTop;
	372	this.originalLeft = this.element.offsetLeft;	455	this.originalLeft = this.element.offsetLeft;
	373		456
	374	var fontSize = Element.getStyle(~~this~~.~~element~~,'font-size') \|\| '100%';	457	var fontSize = this.element.getStyle('font-size') \|\| '100%';
	375	['em','px','%'].each( function(fontSizeType) {	458	['em','px','%','pt'].each( function(fontSizeType) {
	376	if(fontSize.indexOf(fontSizeType)>0) {	459	if(fontSize.indexOf(fontSizeType)>0) {
	377	this.fontSize = parseFloat(fontSize);	460	this.fontSize = parseFloat(fontSize);
	378	this.fontSizeType = fontSizeType;	461	this.fontSizeType = fontSizeType;
	@@ -393,16 +476,16 Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
	393	update: function(position) {	476	update: function(position) {
	394	var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);	477	var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
	395	if(this.options.scaleContent && this.fontSize)	478	if(this.options.scaleContent && this.fontSize)
	396	Element.setStyle(~~this~~.~~element~~, {fontSize: this.fontSize * currentScale + this.fontSizeType });	479	this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
	397	this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);	480	this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
	398	},	481	},
	399	finish: function(position) {	482	finish: function(position) {
	400	if (this.restoreAfterFinish) Element.setStyle(~~this~~.~~element~~, this.originalStyle);	483	if(this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
	401	},	484	},
	402	setDimensions: function(height, width) {	485	setDimensions: function(height, width) {
	403	var d = {};	486	var d = {};
	404	if(this.options.scaleX) d.width = width + 'px';	487	if(this.options.scaleX) d.width = Math.round(width) + 'px';
	405	if(this.options.scaleY) d.height = height + 'px';	488	if(this.options.scaleY) d.height = Math.round(height) + 'px';
	406	if(this.options.scaleFromCenter) {	489	if(this.options.scaleFromCenter) {
	407	var topd = (height - this.dims[0])/2;	490	var topd = (height - this.dims[0])/2;
	408	var leftd = (width - this.dims[1])/2;	491	var leftd = (width - this.dims[1])/2;
	@@ -414,7 +497,7 Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
	414	if(this.options.scaleX) d.left = -leftd + 'px';	497	if(this.options.scaleX) d.left = -leftd + 'px';
	415	}	498	}
	416	}	499	}
	417	Element.setStyle(~~this~~.~~element~~, d);	500	this.element.setStyle(d);
	418	}	501	}
	419	});	502	});
	420		503
	@@ -422,30 +505,31 Effect.Highlight = Class.create();
	422	Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype), {	505	Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype), {
	423	initialize: function(element) {	506	initialize: function(element) {
	424	this.element = $(element);	507	this.element = $(element);
			508	if(!this.element) throw(Effect._elementDoesNotExistError);
	425	var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] \|\| {});	509	var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] \|\| {});
	426	this.start(options);	510	this.start(options);
	427	},	511	},
	428	setup: function() {	512	setup: function() {
	429	// Prevent executing on elements not in the layout flow	513	// Prevent executing on elements not in the layout flow
	430	if(Element.getStyle(~~this~~.~~element~~, 'display')=='none') { this.cancel(); return; }	514	if(this.element.getStyle('display')=='none') { this.cancel(); return; }
	431	// Disable background image during the effect	515	// Disable background image during the effect
	432	this.oldStyle = {	516	this.oldStyle = {
	433	backgroundImage: Element.getStyle(~~this~~.~~element~~, 'background-image') };	517	backgroundImage: this.element.getStyle('background-image') };
	434	Element.setStyle(~~this~~.~~element~~, {backgroundImage: 'none'});	518	this.element.setStyle({backgroundImage: 'none'});
	435	if(!this.options.endcolor)	519	if(!this.options.endcolor)
	436	this.options.endcolor = Element.getStyle(~~this~~.~~element~~, 'background-color').parseColor('#ffffff');	520	this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
	437	if(!this.options.restorecolor)	521	if(!this.options.restorecolor)
	438	this.options.restorecolor = Element.getStyle(~~this~~.~~element~~, 'background-color');	522	this.options.restorecolor = this.element.getStyle('background-color');
	439	// init color calculations	523	// init color calculations
	440	this._base = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i2+1,i2+3),16) }.bind(this));	524	this._base = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i2+1,i2+3),16) }.bind(this));
	441	this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i2+1,i2+3),16)-this._base[i] }.bind(this));	525	this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i2+1,i2+3),16)-this._base[i] }.bind(this));
	442	},	526	},
	443	update: function(position) {	527	update: function(position) {
	444	Element.setStyle(~~this~~.~~element~~,{backgroundColor: $R(0,2).inject('#',function(m,v,i){	528	this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
	445	return m+(Math.round(this._base[i]+(this._delta[i]*position)).toColorPart()); }.bind(this)) });	529	return m+(Math.round(this._base[i]+(this._delta[i]*position)).toColorPart()); }.bind(this)) });
	446	},	530	},
	447	finish: function() {	531	finish: function() {
	448	Element.setStyle(~~this~~.~~element~~, Object.extend(this.oldStyle, {	532	this.element.setStyle(Object.extend(this.oldStyle, {
	449	backgroundColor: this.options.restorecolor	533	backgroundColor: this.options.restorecolor
	450	}));	534	}));
	451	}	535	}
	@@ -479,86 +563,93 Object.extend(Object.extend(Effect.ScrollTo.prototype, Effect.Base.prototype), {
	479	/* ------------- combination effects ------------- */	563	/* ------------- combination effects ------------- */
	480		564
	481	Effect.Fade = function(element) {	565	Effect.Fade = function(element) {
	482	var oldOpacity = Element.getInlineOpacity(element);	566	element = $(element);
			567	var oldOpacity = element.getInlineOpacity();
	483	var options = Object.extend({	568	var options = Object.extend({
	484	from: Element.getOpacity(~~element~~) \|\| 1.0,	569	from: element.getOpacity() \|\| 1.0,
	485	to: 0.0,	570	to: 0.0,
	486	afterFinishInternal: function(effect) { ~~with~~(~~Element~~) {	571	afterFinishInternal: function(effect) {
	487	if(effect.options.to!=0) return;	572	if(effect.options.to!=0) return;
	488	hide(effect.element);	573	effect.element.hide().setStyle({opacity: oldOpacity});
	489	setStyle(effect.element, {opacity: oldOpacity}); }}	574	}}, arguments[1] \|\| {});
	490	}, arguments[1] \|\| {});
	491	return new Effect.Opacity(element,options);	575	return new Effect.Opacity(element,options);
	492	}	576	}
	493		577
	494	Effect.Appear = function(element) {	578	Effect.Appear = function(element) {
			579	element = $(element);
	495	var options = Object.extend({	580	var options = Object.extend({
	496	from: (Element.getStyle(~~element~~, 'display') == 'none' ? 0.0 : Element.getOpacity(~~element~~) \|\| 0.0),	581	from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() \|\| 0.0),
	497	to: 1.0,	582	to: 1.0,
	498	beforeSetup: function(effect) { with(Element) {	583	// force Safari to render floated elements properly
	499	setOpacity(effect.element, effect.options.from);	584	afterFinishInternal: function(effect) {
	500	~~show~~(effect.element); }}	585	effect.element.forceRerendering();
	501	}, arguments[1] \|\| {});	586	},
			587	beforeSetup: function(effect) {
			588	effect.element.setOpacity(effect.options.from).show();
			589	}}, arguments[1] \|\| {});
	502	return new Effect.Opacity(element,options);	590	return new Effect.Opacity(element,options);
	503	}	591	}
	504		592
	505	Effect.Puff = function(element) {	593	Effect.Puff = function(element) {
	506	element = $(element);	594	element = $(element);
	507	var oldStyle = { opacity: Element.getInlineOpacity(element), position: Element.getStyle(element, 'position') };	595	var oldStyle = {
			596	opacity: element.getInlineOpacity(),
			597	position: element.getStyle('position'),
			598	top: element.style.top,
			599	left: element.style.left,
			600	width: element.style.width,
			601	height: element.style.height
			602	};
	508	return new Effect.Parallel(	603	return new Effect.Parallel(
	509	[ new Effect.Scale(element, 200,	604	[ new Effect.Scale(element, 200,
	510	{ sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }),	605	{ sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }),
	511	new Effect.Opacity(element, { sync: true, to: 0.0 } ) ],	606	new Effect.Opacity(element, { sync: true, to: 0.0 } ) ],
	512	Object.extend({ duration: 1.0,	607	Object.extend({ duration: 1.0,
	513	beforeSetupInternal: function(effect) { ~~with~~(~~Element~~) {	608	beforeSetupInternal: function(effect) {
	514	~~setStyl~~e(effect.effects[0].element, {~~position~~: ~~'absolute'~~}); ~~}},~~	609	Position.absolutize(effect.effects[0].element)
	515	afterFinishInternal: function(effect) { with(Element) {	610	},
	516	hide(effect.effects[0].element);	611	afterFinishInternal: function(effect) {
	517	~~setStyle~~(effect.effects[0].element, oldStyle); }}	612	effect.effects[0].element.hide().setStyle(oldStyle); }
	518	}, arguments[1] \|\| {})	613	}, arguments[1] \|\| {})
	519	);	614	);
	520	}	615	}
	521		616
	522	Effect.BlindUp = function(element) {	617	Effect.BlindUp = function(element) {
	523	element = $(element);	618	element = $(element);
	524	Element.makeClipping(~~element~~);	619	element.makeClipping();
	525	return new Effect.Scale(element, 0,	620	return new Effect.Scale(element, 0,
	526	Object.extend({ scaleContent: false,	621	Object.extend({ scaleContent: false,
	527	scaleX: false,	622	scaleX: false,
	528	restoreAfterFinish: true,	623	restoreAfterFinish: true,
	529	afterFinishInternal: function(effect) { ~~with~~(~~Element~~) {	624	afterFinishInternal: function(effect) {
	530	[hide, undoClipping].call(effect.element); }}	625	effect.element.hide().undoClipping();
			626	}
	531	}, arguments[1] \|\| {})	627	}, arguments[1] \|\| {})
	532	);	628	);
	533	}	629	}
	534		630
	535	Effect.BlindDown = function(element) {	631	Effect.BlindDown = function(element) {
	536	element = $(element);	632	element = $(element);
	537	var oldHeight = Element.getStyle(element, 'height');	633	var elementDimensions = element.getDimensions();
	538	var elementDimensions = Element.getDimensions(element);	634	return new Effect.Scale(element, 100, Object.extend({
	539	return new Effect.Scale(element, 100,	635	scaleContent: false,
	540	Object.extend({ scaleContent: false,	636	scaleX: false,
	541	~~scaleX~~: ~~false~~,	637	scaleFrom: 0,
	542	scaleFrom: 0,	638	scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
	543	scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},	639	restoreAfterFinish: true,
	544	restoreAfterFinish: true,	640	afterSetup: function(effect) {
	545	afterSetup: function(effect) { with(Element) {	641	effect.element.makeClipping().setStyle({height: '0px'}).show();
	546	makeClipping(effect.element);	642	},
	547	setStyle(effect.element, {height: '0px'});	643	afterFinishInternal: function(effect) {
	548	~~show~~(effect.element);	644	effect.element.undoClipping();
	549	}},	645	}
	550	afterFinishInternal: function(effect) { with(Element) {	646	}, arguments[1] \|\| {}));
	551	undoClipping(effect.element);
	552	setStyle(effect.element, {height: oldHeight});
	553	}}
	554	}, arguments[1] \|\| {})
	555	);
	556	}	647	}
	557		648
	558	Effect.SwitchOff = function(element) {	649	Effect.SwitchOff = function(element) {
	559	element = $(element);	650	element = $(element);
	560	var oldOpacity = Element.getInlineOpacity(~~element~~);	651	var oldOpacity = element.getInlineOpacity();
	561	return new Effect.Appear(element, {	652	return new Effect.Appear(element, Object.extend({
	562	duration: 0.4,	653	duration: 0.4,
	563	from: 0,	654	from: 0,
	564	transition: Effect.Transitions.flicker,	655	transition: Effect.Transitions.flicker,
	@@ -566,127 +657,123 Effect.SwitchOff = function(element) {
	566	new Effect.Scale(effect.element, 1, {	657	new Effect.Scale(effect.element, 1, {
	567	duration: 0.3, scaleFromCenter: true,	658	duration: 0.3, scaleFromCenter: true,
	568	scaleX: false, scaleContent: false, restoreAfterFinish: true,	659	scaleX: false, scaleContent: false, restoreAfterFinish: true,
	569	beforeSetup: function(effect) { ~~with~~(~~Element~~) {	660	beforeSetup: function(effect) {
	570	[~~makePositioned~~,~~makeClipping~~].~~call~~(effect.element);	661	effect.element.makePositioned().makeClipping();
	571	}},	662	},
	572	afterFinishInternal: function(effect) { ~~with~~(~~Element~~) {	663	afterFinishInternal: function(effect) {
	573	[hide,undoClipping,undoPositioned].call(effect.element);	664	effect.element.hide().undoClipping().undoPositioned().setStyle({opacity: oldOpacity});
	574	setStyle(effect.element, {opacity: oldOpacity});	665	}
	575	}}
	576	})	666	})
	577	}	667	}
	578	});	668	}, arguments[1] \|\| {}));
	579	}	669	}
	580		670
	581	Effect.DropOut = function(element) {	671	Effect.DropOut = function(element) {
	582	element = $(element);	672	element = $(element);
	583	var oldStyle = {	673	var oldStyle = {
	584	top: Element.getStyle(~~element~~, 'top'),	674	top: element.getStyle('top'),
	585	left: Element.getStyle(~~element~~, 'left'),	675	left: element.getStyle('left'),
	586	opacity: Element.getInlineOpacity(~~element~~) };	676	opacity: element.getInlineOpacity() };
	587	return new Effect.Parallel(	677	return new Effect.Parallel(
	588	[ new Effect.MoveBy(element, ~~100~~, 0, { sync: true }),	678	[ new Effect.Move(element, {x: 0, y: 100, sync: true }),
	589	new Effect.Opacity(element, { sync: true, to: 0.0 }) ],	679	new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
	590	Object.extend(	680	Object.extend(
	591	{ duration: 0.5,	681	{ duration: 0.5,
	592	beforeSetup: function(effect) { ~~with~~(~~Element~~) {	682	beforeSetup: function(effect) {
	593	~~makePositioned~~(effect.effects[0].element); ~~}},~~	683	effect.effects[0].element.makePositioned();
	594	afterFinishInternal: function(effect) { with(Element) {	684	},
	595	[hide, undoPositioned].call(effect.effects[0].element);	685	afterFinishInternal: function(effect) {
	596	~~setStyle~~(effect.effects[0].element, oldStyle); }}	686	effect.effects[0].element.hide().undoPositioned().setStyle(oldStyle);
			687	}
	597	}, arguments[1] \|\| {}));	688	}, arguments[1] \|\| {}));
	598	}	689	}
	599		690
	600	Effect.Shake = function(element) {	691	Effect.Shake = function(element) {
	601	element = $(element);	692	element = $(element);
	602	var oldStyle = {	693	var oldStyle = {
	603	top: Element.getStyle(~~element~~, 'top'),	694	top: element.getStyle('top'),
	604	left: Element.getStyle(~~element~~, 'left') };	695	left: element.getStyle('left') };
	605	return new Effect.MoveBy(element, 0, 20,	696	return new Effect.Move(element,
	606	{ duration: 0.05, afterFinishInternal: function(effect) {	697	{ x: 20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
	607	new Effect.MoveBy(effect.element, 0, -40,	698	new Effect.Move(effect.element,
	608	{ duration: 0.1, afterFinishInternal: function(effect) {	699	{ x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
	609	new Effect.MoveBy(effect.element, 0, 40,	700	new Effect.Move(effect.element,
	610	{ duration: 0.1, afterFinishInternal: function(effect) {	701	{ x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
	611	new Effect.MoveBy(effect.element, 0, -40,	702	new Effect.Move(effect.element,
	612	{ duration: 0.1, afterFinishInternal: function(effect) {	703	{ x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
	613	new Effect.MoveBy(effect.element, 0, 40,	704	new Effect.Move(effect.element,
	614	{ duration: 0.1, afterFinishInternal: function(effect) {	705	{ x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
	615	new Effect.MoveBy(effect.element, 0, -20,	706	new Effect.Move(effect.element,
	616	{ duration: 0.05, afterFinishInternal: function(effect) { ~~with~~(~~Element~~) {	707	{ x: -20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
	617	~~undoPositioned~~(effect.element);	708	effect.element.undoPositioned().setStyle(oldStyle);
	618	setStyle(effect.element, oldStyle);	709	}}) }}) }}) }}) }}) }});
	619	}}}) }}) }}) }}) }}) }});
	620	}	710	}
	621		711
	622	Effect.SlideDown = function(element) {	712	Effect.SlideDown = function(element) {
	623	element = $(element);	713	element = $(element).cleanWhitespace();
	624	Element.cleanWhitespace(element);
	625	// SlideDown need to have the content of the element wrapped in a container element with fixed height!	714	// SlideDown need to have the content of the element wrapped in a container element with fixed height!
	626	var oldInnerBottom = Element.getStyle(~~element~~.~~firstChild~~, 'bottom');	715	var oldInnerBottom = element.down().getStyle('bottom');
	627	var elementDimensions = Element.getDimensions(~~element~~);	716	var elementDimensions = element.getDimensions();
	628	return new Effect.Scale(element, 100, Object.extend({	717	return new Effect.Scale(element, 100, Object.extend({
	629	scaleContent: false,	718	scaleContent: false,
	630	scaleX: false,	719	scaleX: false,
	631	scaleFrom: 0,	720	scaleFrom: window.opera ? 0 : 1,
	632	scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},	721	scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
	633	restoreAfterFinish: true,	722	restoreAfterFinish: true,
	634	afterSetup: function(effect) { ~~with~~(~~Element~~) {	723	afterSetup: function(effect) {
	635	~~makePositioned~~(effect.element);	724	effect.element.makePositioned();
	636	makePositioned(effect.element.firstChild);	725	effect.element.down().makePositioned();
	637	if(window.opera) ~~setStyle~~(effect.element, {top: ''});	726	if(window.opera) effect.element.setStyle({top: ''});
	638	makeClipping(effect.element);	727	effect.element.makeClipping().setStyle({height: '0px'}).show();
	639	setStyle(effect.element, {height: '0px'});	728	},
	640	show(element); }},	729	afterUpdateInternal: function(effect) {
	641	afterUpdateInternal: function(effect) { with(Element) {	730	effect.element.down().setStyle({bottom:
	642	setStyle(effect.element.firstChild, {bottom:	731	(effect.dims[0] - effect.element.clientHeight) + 'px' });
	643	(effect.dims[0] - effect.element.clientHeight) + 'px' }); }},	732	},
	644	afterFinishInternal: function(effect) { ~~with~~(~~Element~~) {	733	afterFinishInternal: function(effect) {
	645	undoClipping(effect.element);	734	effect.element.undoClipping().undoPositioned();
	646	undoPositioned(effect.element.firstChild);	735	effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); }
	647	undoPositioned(effect.element);
	648	setStyle(effect.element.firstChild, {bottom: oldInnerBottom}); }}
	649	}, arguments[1] \|\| {})	736	}, arguments[1] \|\| {})
	650	);	737	);
	651	}	738	}
	652		739
	653	Effect.SlideUp = function(element) {	740	Effect.SlideUp = function(element) {
	654	element = $(element);	741	element = $(element).cleanWhitespace();
	655	Element.cleanWhitespace(element);	742	var oldInnerBottom = element.down().getStyle('bottom');
	656	var oldInnerBottom = Element.getStyle(element.firstChild, 'bottom');	743	return new Effect.Scale(element, window.opera ? 0 : 1,
	657	return new Effect.Scale(element, 0,
	658	Object.extend({ scaleContent: false,	744	Object.extend({ scaleContent: false,
	659	scaleX: false,	745	scaleX: false,
	660	scaleMode: 'box',	746	scaleMode: 'box',
	661	scaleFrom: 100,	747	scaleFrom: 100,
	662	restoreAfterFinish: true,	748	restoreAfterFinish: true,
	663	beforeStartInternal: function(effect) { ~~with~~(~~Element~~) {	749	beforeStartInternal: function(effect) {
	664	~~makePositioned~~(effect.element);	750	effect.element.makePositioned();
	665	makePositioned(effect.element.firstChild);	751	effect.element.down().makePositioned();
	666	if(window.opera) ~~setStyle~~(effect.element, {top: ''});	752	if(window.opera) effect.element.setStyle({top: ''});
	667	makeClipping(effect.element);	753	effect.element.makeClipping().show();
	668	show(element); }},	754	},
	669	afterUpdateInternal: function(effect) { ~~with~~(~~Element~~) {	755	afterUpdateInternal: function(effect) {
	670	~~setStyle~~(effect.element.~~firstChild~~, {bottom:	756	effect.element.down().setStyle({bottom:
	671	(effect.dims[0] - effect.element.clientHeight) + 'px' }); ~~}},~~	757	(effect.dims[0] - effect.element.clientHeight) + 'px' });
	672	afterFinishInternal: function(effect) { with(Element) {	758	},
	673	[hide, undoClipping].call(effect.element);	759	afterFinishInternal: function(effect) {
	674	undoPositioned(effect.element.firstChild);	760	effect.element.hide().undoClipping().undoPositioned().setStyle({bottom: oldInnerBottom});
	675	undoPositioned(effect.element);	761	effect.element.down().undoPositioned();
	676	setStyle(effect.element.firstChild, {bottom: oldInnerBottom}); }}	762	}
	677	}, arguments[1] \|\| {})	763	}, arguments[1] \|\| {})
	678	);	764	);
	679	}	765	}
	680		766
	681	// Bug in opera makes the TD containing this element expand for a instance after finish	767	// Bug in opera makes the TD containing this element expand for a instance after finish
	682	Effect.Squish = function(element) {	768	Effect.Squish = function(element) {
	683	return new Effect.Scale(element, window.opera ? 1 : 0,	769	return new Effect.Scale(element, window.opera ? 1 : 0, {
	684	{ restoreAfterFinish: true,	770	restoreAfterFinish: true,
	685	beforeSetup: function(effect) { ~~with~~(~~Element~~) {	771	beforeSetup: function(effect) {
	686	makeClipping(effect.element); }},	772	effect.element.makeClipping();
	687	afterFinishInternal: function(effect) { with(Element) {	773	},
	688	hide(effect.element);	774	afterFinishInternal: function(effect) {
	689	undoClipping(effect.element); }}	775	effect.element.hide().undoClipping();
			776	}
	690	});	777	});
	691	}	778	}
	692		779
	@@ -694,7 +781,7 Effect.Grow = function(element) {
	694	element = $(element);	781	element = $(element);
	695	var options = Object.extend({	782	var options = Object.extend({
	696	direction: 'center',	783	direction: 'center',
	697	moveTransistion: Effect.Transitions.sinoidal,	784	moveTransition: Effect.Transitions.sinoidal,
	698	scaleTransition: Effect.Transitions.sinoidal,	785	scaleTransition: Effect.Transitions.sinoidal,
	699	opacityTransition: Effect.Transitions.full	786	opacityTransition: Effect.Transitions.full
	700	}, arguments[1] \|\| {});	787	}, arguments[1] \|\| {});
	@@ -703,9 +790,9 Effect.Grow = function(element) {
	703	left: element.style.left,	790	left: element.style.left,
	704	height: element.style.height,	791	height: element.style.height,
	705	width: element.style.width,	792	width: element.style.width,
	706	opacity: Element.getInlineOpacity(~~element~~) };	793	opacity: element.getInlineOpacity() };
	707		794
	708	var dims = Element.getDimensions(~~element~~);	795	var dims = element.getDimensions();
	709	var initialMoveX, initialMoveY;	796	var initialMoveX, initialMoveY;
	710	var moveX, moveY;	797	var moveX, moveY;
	711		798
	@@ -737,27 +824,27 Effect.Grow = function(element) {
	737	break;	824	break;
	738	}	825	}
	739		826
	740	return new Effect.MoveBy(element, ~~initialMoveY~~, ~~initialMoveX~~, {	827	return new Effect.Move(element, {
			828	x: initialMoveX,
			829	y: initialMoveY,
	741	duration: 0.01,	830	duration: 0.01,
	742	beforeSetup: function(effect) { ~~with~~(~~Element~~) {	831	beforeSetup: function(effect) {
	743	hide(effect.element);	832	effect.element.hide().makeClipping().makePositioned();
	744	makeClipping(effect.element);	833	},
	745	makePositioned(effect.element);
	746	}},
	747	afterFinishInternal: function(effect) {	834	afterFinishInternal: function(effect) {
	748	new Effect.Parallel(	835	new Effect.Parallel(
	749	[ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),	836	[ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
	750	new Effect.MoveBy(effect.element, ~~moveY~~, moveX, { sync: true, transition: options.moveTransition }),	837	new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
	751	new Effect.Scale(effect.element, 100, {	838	new Effect.Scale(effect.element, 100, {
	752	scaleMode: { originalHeight: dims.height, originalWidth: dims.width },	839	scaleMode: { originalHeight: dims.height, originalWidth: dims.width },
	753	sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})	840	sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
	754	], Object.extend({	841	], Object.extend({
	755	beforeSetup: function(effect) { ~~with~~(~~Element~~) {	842	beforeSetup: function(effect) {
	756	~~setStyle~~(effect.effects[0].element, {height: '0px'});	843	effect.effects[0].element.setStyle({height: '0px'}).show();
	757	show(effect.effects[0].element); }},	844	},
	758	afterFinishInternal: function(effect) { ~~with~~(~~Element~~) {	845	afterFinishInternal: function(effect) {
	759	[undoClipping, undoPositioned].call(effect.effects[0].element);	846	effect.effects[0].element.undoClipping().undoPositioned().setStyle(oldStyle);
	760	setStyle(effect.effects[0].element, oldStyle); }}	847	}
	761	}, options)	848	}, options)
	762	)	849	)
	763	}	850	}
	@@ -768,7 +855,7 Effect.Shrink = function(element) {
	768	element = $(element);	855	element = $(element);
	769	var options = Object.extend({	856	var options = Object.extend({
	770	direction: 'center',	857	direction: 'center',
	771	moveTransistion: Effect.Transitions.sinoidal,	858	moveTransition: Effect.Transitions.sinoidal,
	772	scaleTransition: Effect.Transitions.sinoidal,	859	scaleTransition: Effect.Transitions.sinoidal,
	773	opacityTransition: Effect.Transitions.none	860	opacityTransition: Effect.Transitions.none
	774	}, arguments[1] \|\| {});	861	}, arguments[1] \|\| {});
	@@ -777,9 +864,9 Effect.Shrink = function(element) {
	777	left: element.style.left,	864	left: element.style.left,
	778	height: element.style.height,	865	height: element.style.height,
	779	width: element.style.width,	866	width: element.style.width,
	780	opacity: Element.getInlineOpacity(~~element~~) };	867	opacity: element.getInlineOpacity() };
	781		868
	782	var dims = Element.getDimensions(~~element~~);	869	var dims = element.getDimensions();
	783	var moveX, moveY;	870	var moveX, moveY;
	784		871
	785	switch (options.direction) {	872	switch (options.direction) {
	@@ -807,13 +894,13 Effect.Shrink = function(element) {
	807	return new Effect.Parallel(	894	return new Effect.Parallel(
	808	[ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),	895	[ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
	809	new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),	896	new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
	810	new Effect.MoveBy(element, ~~moveY~~, moveX, { sync: true, transition: options.moveTransition })	897	new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
	811	], Object.extend({	898	], Object.extend({
	812	beforeStartInternal: function(effect) { ~~with~~(~~Element~~) {	899	beforeStartInternal: function(effect) {
	813	[makePositioned, makeClipping].call(effect.effects[0].element) }},	900	effect.effects[0].element.makePositioned().makeClipping();
	814	afterFinishInternal: function(effect) { with(Element) {	901	},
	815	[hide, undoClipping, undoPositioned].call(effect.effects[0].element);	902	afterFinishInternal: function(effect) {
	816	~~setStyle~~(effect.effects[0].element, oldStyle); }}	903	effect.effects[0].element.hide().undoClipping().undoPositioned().setStyle(oldStyle); }
	817	}, options)	904	}, options)
	818	);	905	);
	819	}	906	}
	@@ -821,13 +908,13 Effect.Shrink = function(element) {
	821	Effect.Pulsate = function(element) {	908	Effect.Pulsate = function(element) {
	822	element = $(element);	909	element = $(element);
	823	var options = arguments[1] \|\| {};	910	var options = arguments[1] \|\| {};
	824	var oldOpacity = Element.getInlineOpacity(~~element~~);	911	var oldOpacity = element.getInlineOpacity();
	825	var transition = options.transition \|\| Effect.Transitions.sinoidal;	912	var transition = options.transition \|\| Effect.Transitions.sinoidal;
	826	var reverser = function(pos){ return transition(1-Effect.Transitions.pulse(pos)) };	913	var reverser = function(pos){ return transition(1-Effect.Transitions.pulse(pos, options.pulses)) };
	827	reverser.bind(transition);	914	reverser.bind(transition);
	828	return new Effect.Opacity(element,	915	return new Effect.Opacity(element,
	829	Object.extend(Object.extend({ duration: 3.0, from: 0,	916	Object.extend(Object.extend({ duration: 2.0, from: 0,
	830	afterFinishInternal: function(effect) { Element.setStyle(~~effect~~.~~element~~, {opacity: oldOpacity}); }	917	afterFinishInternal: function(effect) { effect.element.setStyle({opacity: oldOpacity}); }
	831	}, options), {transition: reverser}));	918	}, options), {transition: reverser}));
	832	}	919	}
	833		920
	@@ -838,7 +925,7 Effect.Fold = function(element) {
	838	left: element.style.left,	925	left: element.style.left,
	839	width: element.style.width,	926	width: element.style.width,
	840	height: element.style.height };	927	height: element.style.height };
	841	Element.makeClipping(~~element~~);	928	element.makeClipping();
	842	return new Effect.Scale(element, 5, Object.extend({	929	return new Effect.Scale(element, 5, Object.extend({
	843	scaleContent: false,	930	scaleContent: false,
	844	scaleX: false,	931	scaleX: false,
	@@ -846,9 +933,156 Effect.Fold = function(element) {
	846	new Effect.Scale(element, 1, {	933	new Effect.Scale(element, 1, {
	847	scaleContent: false,	934	scaleContent: false,
	848	scaleY: false,	935	scaleY: false,
	849	afterFinishInternal: function(effect) { ~~with~~(~~Element~~) {	936	afterFinishInternal: function(effect) {
	850	[hide, undoClipping].call(effect.element);	937	effect.element.hide().undoClipping().setStyle(oldStyle);
	851	setStyle(effect.element, oldStyle);	938	} });
	852	}} });
	853	}}, arguments[1] \|\| {}));	939	}}, arguments[1] \|\| {}));
	854	}	940	};
			941
			942	Effect.Morph = Class.create();
			943	Object.extend(Object.extend(Effect.Morph.prototype, Effect.Base.prototype), {
			944	initialize: function(element) {
			945	this.element = $(element);
			946	if(!this.element) throw(Effect._elementDoesNotExistError);
			947	var options = Object.extend({
			948	style: ''
			949	}, arguments[1] \|\| {});
			950	this.start(options);
			951	},
			952	setup: function(){
			953	function parseColor(color){
			954	if(!color \|\| ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
			955	color = color.parseColor();
			956	return $R(0,2).map(function(i){
			957	return parseInt( color.slice(i2+1,i2+3), 16 )
			958	});
			959	}
			960	this.transforms = this.options.style.parseStyle().map(function(property){
			961	var originalValue = this.element.getStyle(property[0]);
			962	return $H({
			963	style: property[0],
			964	originalValue: property[1].unit=='color' ?
			965	parseColor(originalValue) : parseFloat(originalValue \|\| 0),
			966	targetValue: property[1].unit=='color' ?
			967	parseColor(property[1].value) : property[1].value,
			968	unit: property[1].unit
			969	});
			970	}.bind(this)).reject(function(transform){
			971	return (
			972	(transform.originalValue == transform.targetValue) \|\|
			973	(
			974	transform.unit != 'color' &&
			975	(isNaN(transform.originalValue) \|\| isNaN(transform.targetValue))
			976	)
			977	)
			978	});
			979	},
			980	update: function(position) {
			981	var style = $H(), value = null;
			982	this.transforms.each(function(transform){
			983	value = transform.unit=='color' ?
			984	$R(0,2).inject('#',function(m,v,i){
			985	return m+(Math.round(transform.originalValue[i]+
			986	(transform.targetValue[i] - transform.originalValue[i])*position)).toColorPart() }) :
			987	transform.originalValue + Math.round(
			988	((transform.targetValue - transform.originalValue) * position) * 1000)/1000 + transform.unit;
			989	style[transform.style] = value;
			990	});
			991	this.element.setStyle(style);
			992	}
			993	});
			994
			995	Effect.Transform = Class.create();
			996	Object.extend(Effect.Transform.prototype, {
			997	initialize: function(tracks){
			998	this.tracks = [];
			999	this.options = arguments[1] \|\| {};
			1000	this.addTracks(tracks);
			1001	},
			1002	addTracks: function(tracks){
			1003	tracks.each(function(track){
			1004	var data = $H(track).values().first();
			1005	this.tracks.push($H({
			1006	ids: $H(track).keys().first(),
			1007	effect: Effect.Morph,
			1008	options: { style: data }
			1009	}));
			1010	}.bind(this));
			1011	return this;
			1012	},
			1013	play: function(){
			1014	return new Effect.Parallel(
			1015	this.tracks.map(function(track){
			1016	var elements = [$(track.ids) \|\| $$(track.ids)].flatten();
			1017	return elements.map(function(e){ return new track.effect(e, Object.extend({ sync:true }, track.options)) });
			1018	}).flatten(),
			1019	this.options
			1020	);
			1021	}
			1022	});
			1023
			1024	Element.CSS_PROPERTIES = ['azimuth', 'backgroundAttachment', 'backgroundColor', 'backgroundImage',
			1025	'backgroundPosition', 'backgroundRepeat', 'borderBottomColor', 'borderBottomStyle',
			1026	'borderBottomWidth', 'borderCollapse', 'borderLeftColor', 'borderLeftStyle', 'borderLeftWidth',
			1027	'borderRightColor', 'borderRightStyle', 'borderRightWidth', 'borderSpacing', 'borderTopColor',
			1028	'borderTopStyle', 'borderTopWidth', 'bottom', 'captionSide', 'clear', 'clip', 'color', 'content',
			1029	'counterIncrement', 'counterReset', 'cssFloat', 'cueAfter', 'cueBefore', 'cursor', 'direction',
			1030	'display', 'elevation', 'emptyCells', 'fontFamily', 'fontSize', 'fontSizeAdjust', 'fontStretch',
			1031	'fontStyle', 'fontVariant', 'fontWeight', 'height', 'left', 'letterSpacing', 'lineHeight',
			1032	'listStyleImage', 'listStylePosition', 'listStyleType', 'marginBottom', 'marginLeft', 'marginRight',
			1033	'marginTop', 'markerOffset', 'marks', 'maxHeight', 'maxWidth', 'minHeight', 'minWidth', 'opacity',
			1034	'orphans', 'outlineColor', 'outlineOffset', 'outlineStyle', 'outlineWidth', 'overflowX', 'overflowY',
			1035	'paddingBottom', 'paddingLeft', 'paddingRight', 'paddingTop', 'page', 'pageBreakAfter', 'pageBreakBefore',
			1036	'pageBreakInside', 'pauseAfter', 'pauseBefore', 'pitch', 'pitchRange', 'position', 'quotes',
			1037	'richness', 'right', 'size', 'speakHeader', 'speakNumeral', 'speakPunctuation', 'speechRate', 'stress',
			1038	'tableLayout', 'textAlign', 'textDecoration', 'textIndent', 'textShadow', 'textTransform', 'top',
			1039	'unicodeBidi', 'verticalAlign', 'visibility', 'voiceFamily', 'volume', 'whiteSpace', 'widows',
			1040	'width', 'wordSpacing', 'zIndex'];
			1041
			1042	Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em\|ex\|px\|in\|cm\|mm\|pt\|pc\|\%))\|0$/;
			1043
			1044	String.prototype.parseStyle = function(){
			1045	var element = Element.extend(document.createElement('div'));
			1046	element.innerHTML = '<div style="' + this + '"></div>';
			1047	var style = element.down().style, styleRules = $H();
			1048
			1049	Element.CSS_PROPERTIES.each(function(property){
			1050	if(style[property]) styleRules[property] = style[property];
			1051	});
			1052
			1053	var result = $H();
			1054
			1055	styleRules.each(function(pair){
			1056	var property = pair[0], value = pair[1], unit = null;
			1057
			1058	if(value.parseColor('#zzzzzz') != '#zzzzzz') {
			1059	value = value.parseColor();
			1060	unit = 'color';
			1061	} else if(Element.CSS_LENGTH.test(value))
			1062	var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/),
			1063	value = parseFloat(components[1]), unit = (components.length == 3) ? components[2] : null;
			1064
			1065	result[property.underscore().dasherize()] = $H({ value:value, unit:unit });
			1066	}.bind(this));
			1067
			1068	return result;
			1069	};
			1070
			1071	Element.morph = function(element, style) {
			1072	new Effect.Morph(element, Object.extend({ style: style }, arguments[2] \|\| {}));
			1073	return element;
			1074	};
			1075
			1076	['setOpacity','getOpacity','getInlineOpacity','forceRerendering','setContentZoom',
			1077	'collectTextNodes','collectTextNodesIgnoreClass','morph'].each(
			1078	function(f) { Element.Methods[f] = Element[f]; }
			1079	);
			1080
			1081	Element.Methods.visualEffect = function(element, effect, options) {
			1082	s = effect.gsub(/_/, '-').camelize();
			1083	effect_class = s.charAt(0).toUpperCase() + s.substring(1);
			1084	new Effect[effect_class](element, options);
			1085	return $(element);
			1086	};
			1087
			1088	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
               },
               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();
                 }
               }
             }
+            String.interpret = function(value){
+              return value == null ? '' : String(value);
+            }
             Object.extend(String.prototype, {
               gsub: function(pattern, replacement) {
                 var result = '', source = this, match;
                 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 = '';
               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;
                 });
               },
                 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) {
                 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 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) {
               collect: function(iterator) {
                 var results = [];
                 this.each(function(value, index) {
-                  results.push(iterator(value, index));
+                  results.push((iterator || Prototype.K)(value, index));
                 });
                 return results;
               },
               },
               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) {
               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);
                 });
               },
               },
               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;
               },
               toArray: function() {
-                return this.collect(Prototype.K);
+                return this.map();
               },
               zip: function() {
                 });
               },
+              size: function() {
+                return this.toArray().length;
+              },
               inspect: function() {
                 return '#<Enumerable:' + this.toArray().inspect() + '>';
               }
               compact: function() {
                 return this.select(function(value) {
-                  return value != undefined || value != null;
+                  return value != null;
                 });
               },
                 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;
                 });
               },
+              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 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, {
                 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();
               }
             }
               ['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);
               },
               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);
               },
                   '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 : '');
                   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 });
                 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 {
                 }
                 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;
                 }
                 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) {
                 }
                 return elements;
               }
+            };
             /*--------------------------------------------------------------------------*/
               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 (['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 value.apply(null, [this].concat($A(arguments)));
                 }
               }
+            };
             Element.Methods = {
               visible: function(element) {
               replace: function(element, html) {
                 element = $(element);
+                html = typeof html == 'undefined' ? '' : html.toString();
                 if (element.outerHTML) {
                   element.outerHTML = html.stripScripts();
                 } else {
               },
               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) {
               },
               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) {
               },
               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 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();
                 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;
               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,
                 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};
                 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':
                 setTimeout(function() {html.evalScripts()}, 10);
                 return element;
               }
+            };
             Object.extend(Element, Element.Methods);
                   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;
               toString: function() {
                 return $A(this).join(' ');
               }
+            };
             Object.extend(Element.ClassNames.prototype, Enumerable);
             var Selector = Class.create();
                 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() + ')';
                     }
                                       ); 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';
                     }
                   });
               compileMatcher: function() {
                 this.match = new Function('element', 'if (!element.tagName) return false; \
+                  element = $(element); \
                   return ' + this.buildMatchExpression());
               },
             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) {
               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));
                 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) {
                 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));
                 }
             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) {
               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;
               },
             Object.extend(Form.Element, Form.Element.Methods);
             var Field = Form.Element;
+            var $F = Form.Element.getValue;
             /*--------------------------------------------------------------------------*/
                   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) {
               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;
                 }
                 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) {

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