zena 0.15.0

data/public/javascripts/scriptaculous.js

@@ -0,0 +1,60 @@
+// script.aculo.us scriptaculous.js v1.8.2, Tue Nov 18 18:30:58 +0100 2008
+
+// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// For details, see the script.aculo.us web site: http://script.aculo.us/
+
+var Scriptaculous = {
+  Version: '1.8.2',
+  require: function(libraryName) {
+    // inserting via DOM fails in Safari 2.0, so brute force approach
+    document.write('<script type="text/javascript" src="'+libraryName+'"><\/script>');
+  },
+  REQUIRED_PROTOTYPE: '1.6.0.3',
+  load: function() {
+    function convertVersionString(versionString) {
+      var v = versionString.replace(/_.*|\./g, '');
+      v = parseInt(v + '0'.times(4-v.length));
+      return versionString.indexOf('_') > -1 ? v-1 : v;
+    }
+
+    if((typeof Prototype=='undefined') ||
+       (typeof Element == 'undefined') ||
+       (typeof Element.Methods=='undefined') ||
+       (convertVersionString(Prototype.Version) <
+        convertVersionString(Scriptaculous.REQUIRED_PROTOTYPE)))
+       throw("script.aculo.us requires the Prototype JavaScript framework >= " +
+        Scriptaculous.REQUIRED_PROTOTYPE);
+
+    var js = /scriptaculous\.js(\?.*)?$/;
+    $$('head script[src]').findAll(function(s) {
+      return s.src.match(js);
+    }).each(function(s) {
+      var path = s.src.replace(js, ''),
+      includes = s.src.match(/\?.*load=([a-z,]*)/);
+      (includes ? includes[1] : 'builder,effects,dragdrop,controls,slider,sound').split(',').each(
+       function(include) { Scriptaculous.require(path+include+'.js') });
+    });
+  }
+};
+
+Scriptaculous.load();

data/public/javascripts/slider.js

@@ -0,0 +1,275 @@
+// script.aculo.us slider.js v1.8.2, Tue Nov 18 18:30:58 +0100 2008
+
+// Copyright (c) 2005-2008 Marty Haught, Thomas Fuchs
+//
+// script.aculo.us is freely distributable under the terms of an MIT-style license.
+// For details, see the script.aculo.us web site: http://script.aculo.us/
+
+if (!Control) var Control = { };
+
+// options:
+//  axis: 'vertical', or 'horizontal' (default)
+//
+// callbacks:
+//  onChange(value)
+//  onSlide(value)
+Control.Slider = Class.create({
+  initialize: function(handle, track, options) {
+    var slider = this;
+
+    if (Object.isArray(handle)) {
+      this.handles = handle.collect( function(e) { return $(e) });
+    } else {
+      this.handles = [$(handle)];
+    }
+
+    this.track   = $(track);
+    this.options = options || { };
+
+    this.axis      = this.options.axis || 'horizontal';
+    this.increment = this.options.increment || 1;
+    this.step      = parseInt(this.options.step || '1');
+    this.range     = this.options.range || $R(0,1);
+
+    this.value     = 0; // assure backwards compat
+    this.values    = this.handles.map( function() { return 0 });
+    this.spans     = this.options.spans ? this.options.spans.map(function(s){ return $(s) }) : false;
+    this.options.startSpan = $(this.options.startSpan || null);
+    this.options.endSpan   = $(this.options.endSpan || null);
+
+    this.restricted = this.options.restricted || false;
+
+    this.maximum   = this.options.maximum || this.range.end;
+    this.minimum   = this.options.minimum || this.range.start;
+
+    // Will be used to align the handle onto the track, if necessary
+    this.alignX = parseInt(this.options.alignX || '0');
+    this.alignY = parseInt(this.options.alignY || '0');
+
+    this.trackLength = this.maximumOffset() - this.minimumOffset();
+
+    this.handleLength = this.isVertical() ?
+      (this.handles[0].offsetHeight != 0 ?
+        this.handles[0].offsetHeight : this.handles[0].style.height.replace(/px$/,"")) :
+      (this.handles[0].offsetWidth != 0 ? this.handles[0].offsetWidth :
+        this.handles[0].style.width.replace(/px$/,""));
+
+    this.active   = false;
+    this.dragging = false;
+    this.disabled = false;
+
+    if (this.options.disabled) this.setDisabled();
+
+    // Allowed values array
+    this.allowedValues = this.options.values ? this.options.values.sortBy(Prototype.K) : false;
+    if (this.allowedValues) {
+      this.minimum = this.allowedValues.min();
+      this.maximum = this.allowedValues.max();
+    }
+
+    this.eventMouseDown = this.startDrag.bindAsEventListener(this);
+    this.eventMouseUp   = this.endDrag.bindAsEventListener(this);
+    this.eventMouseMove = this.update.bindAsEventListener(this);
+
+    // Initialize handles in reverse (make sure first handle is active)
+    this.handles.each( function(h,i) {
+      i = slider.handles.length-1-i;
+      slider.setValue(parseFloat(
+        (Object.isArray(slider.options.sliderValue) ?
+          slider.options.sliderValue[i] : slider.options.sliderValue) ||
+         slider.range.start), i);
+      h.makePositioned().observe("mousedown", slider.eventMouseDown);
+    });
+
+    this.track.observe("mousedown", this.eventMouseDown);
+    document.observe("mouseup", this.eventMouseUp);
+    document.observe("mousemove", this.eventMouseMove);
+
+    this.initialized = true;
+  },
+  dispose: function() {
+    var slider = this;
+    Event.stopObserving(this.track, "mousedown", this.eventMouseDown);
+    Event.stopObserving(document, "mouseup", this.eventMouseUp);
+    Event.stopObserving(document, "mousemove", this.eventMouseMove);
+    this.handles.each( function(h) {
+      Event.stopObserving(h, "mousedown", slider.eventMouseDown);
+    });
+  },
+  setDisabled: function(){
+    this.disabled = true;
+  },
+  setEnabled: function(){
+    this.disabled = false;
+  },
+  getNearestValue: function(value){
+    if (this.allowedValues){
+      if (value >= this.allowedValues.max()) return(this.allowedValues.max());
+      if (value <= this.allowedValues.min()) return(this.allowedValues.min());
+
+      var offset = Math.abs(this.allowedValues[0] - value);
+      var newValue = this.allowedValues[0];
+      this.allowedValues.each( function(v) {
+        var currentOffset = Math.abs(v - value);
+        if (currentOffset <= offset){
+          newValue = v;
+          offset = currentOffset;
+        }
+      });
+      return newValue;
+    }
+    if (value > this.range.end) return this.range.end;
+    if (value < this.range.start) return this.range.start;
+    return value;
+  },
+  setValue: function(sliderValue, handleIdx){
+    if (!this.active) {
+      this.activeHandleIdx = handleIdx || 0;
+      this.activeHandle    = this.handles[this.activeHandleIdx];
+      this.updateStyles();
+    }
+    handleIdx = handleIdx || this.activeHandleIdx || 0;
+    if (this.initialized && this.restricted) {
+      if ((handleIdx>0) && (sliderValue<this.values[handleIdx-1]))
+        sliderValue = this.values[handleIdx-1];
+      if ((handleIdx < (this.handles.length-1)) && (sliderValue>this.values[handleIdx+1]))
+        sliderValue = this.values[handleIdx+1];
+    }
+    sliderValue = this.getNearestValue(sliderValue);
+    this.values[handleIdx] = sliderValue;
+    this.value = this.values[0]; // assure backwards compat
+
+    this.handles[handleIdx].style[this.isVertical() ? 'top' : 'left'] =
+      this.translateToPx(sliderValue);
+
+    this.drawSpans();
+    if (!this.dragging || !this.event) this.updateFinished();
+  },
+  setValueBy: function(delta, handleIdx) {
+    this.setValue(this.values[handleIdx || this.activeHandleIdx || 0] + delta,
+      handleIdx || this.activeHandleIdx || 0);
+  },
+  translateToPx: function(value) {
+    return Math.round(
+      ((this.trackLength-this.handleLength)/(this.range.end-this.range.start)) *
+      (value - this.range.start)) + "px";
+  },
+  translateToValue: function(offset) {
+    return ((offset/(this.trackLength-this.handleLength) *
+      (this.range.end-this.range.start)) + this.range.start);
+  },
+  getRange: function(range) {
+    var v = this.values.sortBy(Prototype.K);
+    range = range || 0;
+    return $R(v[range],v[range+1]);
+  },
+  minimumOffset: function(){
+    return(this.isVertical() ? this.alignY : this.alignX);
+  },
+  maximumOffset: function(){
+    return(this.isVertical() ?
+      (this.track.offsetHeight != 0 ? this.track.offsetHeight :
+        this.track.style.height.replace(/px$/,"")) - this.alignY :
+      (this.track.offsetWidth != 0 ? this.track.offsetWidth :
+        this.track.style.width.replace(/px$/,"")) - this.alignX);
+  },
+  isVertical:  function(){
+    return (this.axis == 'vertical');
+  },
+  drawSpans: function() {
+    var slider = this;
+    if (this.spans)
+      $R(0, this.spans.length-1).each(function(r) { slider.setSpan(slider.spans[r], slider.getRange(r)) });
+    if (this.options.startSpan)
+      this.setSpan(this.options.startSpan,
+        $R(0, this.values.length>1 ? this.getRange(0).min() : this.value ));
+    if (this.options.endSpan)
+      this.setSpan(this.options.endSpan,
+        $R(this.values.length>1 ? this.getRange(this.spans.length-1).max() : this.value, this.maximum));
+  },
+  setSpan: function(span, range) {
+    if (this.isVertical()) {
+      span.style.top = this.translateToPx(range.start);
+      span.style.height = this.translateToPx(range.end - range.start + this.range.start);
+    } else {
+      span.style.left = this.translateToPx(range.start);
+      span.style.width = this.translateToPx(range.end - range.start + this.range.start);
+    }
+  },
+  updateStyles: function() {
+    this.handles.each( function(h){ Element.removeClassName(h, 'selected') });
+    Element.addClassName(this.activeHandle, 'selected');
+  },
+  startDrag: function(event) {
+    if (Event.isLeftClick(event)) {
+      if (!this.disabled){
+        this.active = true;
+
+        var handle = Event.element(event);
+        var pointer  = [Event.pointerX(event), Event.pointerY(event)];
+        var track = handle;
+        if (track==this.track) {
+          var offsets  = Position.cumulativeOffset(this.track);
+          this.event = event;
+          this.setValue(this.translateToValue(
+           (this.isVertical() ? pointer[1]-offsets[1] : pointer[0]-offsets[0])-(this.handleLength/2)
+          ));
+          var offsets  = Position.cumulativeOffset(this.activeHandle);
+          this.offsetX = (pointer[0] - offsets[0]);
+          this.offsetY = (pointer[1] - offsets[1]);
+        } else {
+          // find the handle (prevents issues with Safari)
+          while((this.handles.indexOf(handle) == -1) && handle.parentNode)
+            handle = handle.parentNode;
+
+          if (this.handles.indexOf(handle)!=-1) {
+            this.activeHandle    = handle;
+            this.activeHandleIdx = this.handles.indexOf(this.activeHandle);
+            this.updateStyles();
+
+            var offsets  = Position.cumulativeOffset(this.activeHandle);
+            this.offsetX = (pointer[0] - offsets[0]);
+            this.offsetY = (pointer[1] - offsets[1]);
+          }
+        }
+      }
+      Event.stop(event);
+    }
+  },
+  update: function(event) {
+   if (this.active) {
+      if (!this.dragging) this.dragging = true;
+      this.draw(event);
+      if (Prototype.Browser.WebKit) window.scrollBy(0,0);
+      Event.stop(event);
+   }
+  },
+  draw: function(event) {
+    var pointer = [Event.pointerX(event), Event.pointerY(event)];
+    var offsets = Position.cumulativeOffset(this.track);
+    pointer[0] -= this.offsetX + offsets[0];
+    pointer[1] -= this.offsetY + offsets[1];
+    this.event = event;
+    this.setValue(this.translateToValue( this.isVertical() ? pointer[1] : pointer[0] ));
+    if (this.initialized && this.options.onSlide)
+      this.options.onSlide(this.values.length>1 ? this.values : this.value, this);
+  },
+  endDrag: function(event) {
+    if (this.active && this.dragging) {
+      this.finishDrag(event, true);
+      Event.stop(event);
+    }
+    this.active = false;
+    this.dragging = false;
+  },
+  finishDrag: function(event, success) {
+    this.active = false;
+    this.dragging = false;
+    this.updateFinished();
+  },
+  updateFinished: function() {
+    if (this.initialized && this.options.onChange)
+      this.options.onChange(this.values.length>1 ? this.values : this.value, this);
+    this.event = null;
+  }
+});

data/public/javascripts/sound.js

@@ -0,0 +1,55 @@
+// script.aculo.us sound.js v1.8.2, Tue Nov 18 18:30:58 +0100 2008
+
+// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
+//
+// Based on code created by Jules Gravinese (http://www.webveteran.com/)
+//
+// 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/
+
+Sound = {
+  tracks: {},
+  _enabled: true,
+  template:
+    new Template('<embed style="height:0" id="sound_#{track}_#{id}" src="#{url}" loop="false" autostart="true" hidden="true"/>'),
+  enable: function(){
+    Sound._enabled = true;
+  },
+  disable: function(){
+    Sound._enabled = false;
+  },
+  play: function(url){
+    if(!Sound._enabled) return;
+    var options = Object.extend({
+      track: 'global', url: url, replace: false
+    }, arguments[1] || {});
+
+    if(options.replace && this.tracks[options.track]) {
+      $R(0, this.tracks[options.track].id).each(function(id){
+        var sound = $('sound_'+options.track+'_'+id);
+        sound.Stop && sound.Stop();
+        sound.remove();
+      });
+      this.tracks[options.track] = null;
+    }
+
+    if(!this.tracks[options.track])
+      this.tracks[options.track] = { id: 0 };
+    else
+      this.tracks[options.track].id++;
+
+    options.id = this.tracks[options.track].id;
+    $$('body')[0].insert(
+      Prototype.Browser.IE ? new Element('bgsound',{
+        id: 'sound_'+options.track+'_'+options.id,
+        src: options.url, loop: 1, autostart: true
+      }) : Sound.template.evaluate(options));
+  }
+};
+
+if(Prototype.Browser.Gecko && navigator.userAgent.indexOf("Win") > 0){
+  if(navigator.plugins && $A(navigator.plugins).detect(function(p){ return p.name.indexOf('QuickTime') != -1 }))
+    Sound.template = new Template('<object id="sound_#{track}_#{id}" width="0" height="0" type="audio/mpeg" data="#{url}"/>');
+  else
+    Sound.play = function(){};
+}

data/public/javascripts/tablekit.js

@@ -0,0 +1,965 @@
+/*
+*
+* Copyright (c) 2007 Andrew Tetlaw & Millstream Web Software
+* http://www.millstream.com.au/view/code/tablekit/
+* Version: 1.3b 2008-03-23
+*
+* Permission is hereby granted, free of charge, to any person
+* obtaining a copy of this software and associated documentation
+* files (the "Software"), to deal in the Software without
+* restriction, including without limitation the rights to use, copy,
+* modify, merge, publish, distribute, sublicense, and/or sell copies
+* of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+* *
+*/
+
+// Use the TableKit class constructure if you'd prefer to init your tables as JS objects
+var TableKit = Class.create();
+
+TableKit.prototype = {
+	initialize : function(elm, options) {
+		var table = $(elm);
+		if(table.tagName !== "TABLE") {
+			return;
+		}
+		TableKit.register(table,Object.extend(TableKit.options,options || {}));
+		this.id = table.id;
+		var op = TableKit.option('sortable resizable editable', this.id);
+		if(op.sortable) {
+			TableKit.Sortable.init(table);
+		}
+		if(op.resizable) {
+			TableKit.Resizable.init(table);
+		}
+		if(op.editable) {
+			TableKit.Editable.init(table);
+		}
+	},
+	sort : function(column, order) {
+		TableKit.Sortable.sort(this.id, column, order);
+	},
+	resizeColumn : function(column, w) {
+		TableKit.Resizable.resize(this.id, column, w);
+	},
+	editCell : function(row, column) {
+		TableKit.Editable.editCell(this.id, row, column);
+	}
+};
+
+Object.extend(TableKit, {
+	getBodyRows : function(table) {
+		table = $(table);
+		var id = table.id;
+		if(!TableKit.tables[id].dom.rows) {
+			TableKit.tables[id].dom.rows = (table.tHead && table.tHead.rows.length > 0) ? $A(table.tBodies[0].rows) : $A(table.rows).without(table.rows[0]);
+		}
+		return TableKit.tables[id].dom.rows;
+	},
+	getHeaderCells : function(table, cell) {
+		if(!table) { table = $(cell).up('table'); }
+		var id = table.id;
+		if(!TableKit.tables[id].dom.head) {
+			TableKit.tables[id].dom.head = $A((table.tHead && table.tHead.rows.length > 0) ? table.tHead.rows[table.tHead.rows.length-1].cells : table.rows[0].cells);
+		}
+		return TableKit.tables[id].dom.head;
+	},
+	getCellIndex : function(cell) {
+		return $A(cell.parentNode.cells).indexOf(cell);
+	},
+	getRowIndex : function(row) {
+		return $A(row.parentNode.rows).indexOf(row);
+	},
+	getCellText : function(cell, refresh) {
+		if(!cell) { return ""; }
+		var data = TableKit.getCellData(cell);
+		if(refresh || data.refresh || !data.textContent) {
+			data.textContent = cell.textContent ? cell.textContent : cell.innerText;
+			data.refresh = false;
+		}
+		return data.textContent;
+	},
+	getCellData : function(cell) {
+	  var t = null;
+		if(!cell.id) {
+			t = $(cell).up('table');
+			cell.id = t.id + "-cell-" + TableKit._getc();
+		}
+		var tblid = t ? t.id : cell.id.match(/(.*)-cell.*/)[1];
+		if(!TableKit.tables[tblid].dom.cells[cell.id]) {
+			TableKit.tables[tblid].dom.cells[cell.id] = {textContent : '', htmlContent : '', active : false};
+		}
+		return TableKit.tables[tblid].dom.cells[cell.id];
+	},
+	register : function(table, options) {
+		if(!table.id) {
+			table.id = "tablekit-table-" + TableKit._getc();
+		}
+		var id = table.id;
+		TableKit.tables[id] = TableKit.tables[id] ?
+		                        Object.extend(TableKit.tables[id], options || {}) :
+		                        Object.extend(
+		                          {dom : {head:null,rows:null,cells:{}},sortable:false,resizable:false,editable:false},
+		                          options || {}
+		                        );
+	},
+	notify : function(eventName, table, event) {
+		if(TableKit.tables[table.id] &&  TableKit.tables[table.id].observers && TableKit.tables[table.id].observers[eventName]) {
+			TableKit.tables[table.id].observers[eventName](table, event);
+		}
+		TableKit.options.observers[eventName](table, event)();
+	},
+	isSortable : function(table) {
+		return TableKit.tables[table.id] ? TableKit.tables[table.id].sortable : false;
+	},
+	isResizable : function(table) {
+		return TableKit.tables[table.id] ? TableKit.tables[table.id].resizable : false;
+	},
+	isEditable : function(table) {
+		return TableKit.tables[table.id] ? TableKit.tables[table.id].editable : false;
+	},
+	setup : function(o) {
+		Object.extend(TableKit.options, o || {} );
+	},
+	option : function(s, id, o1, o2) {
+		o1 = o1 || TableKit.options;
+		o2 = o2 || (id ? (TableKit.tables[id] ? TableKit.tables[id] : {}) : {});
+		var key = id + s;
+		if(!TableKit._opcache[key]){
+			TableKit._opcache[key] = $A($w(s)).inject([],function(a,v){
+				a.push(a[v] = o2[v] || o1[v]);
+				return a;
+			});
+		}
+		return TableKit._opcache[key];
+	},
+	e : function(event) {
+		return event || window.event;
+	},
+	tables : {},
+	_opcache : {},
+	options : {
+		autoLoad : true,
+		stripe : true,
+		sortable : false,
+		resizable : false,
+		editable : true,
+		rowEvenClass : 'roweven',
+		rowOddClass : 'rowodd',
+		sortableSelector : ['table.sortable'],
+		columnClass : 'sortcol',
+		descendingClass : 'sortdesc',
+		ascendingClass : 'sortasc',
+		defaultSortDirection : 1,
+		noSortClass : 'nosort',
+		sortFirstAscendingClass : 'sortfirstasc',
+		sortFirstDecendingClass : 'sortfirstdesc',
+		resizableSelector : ['table.resizable'],
+		minWidth : 10,
+		showHandle : true,
+		resizeOnHandleClass : 'resize-handle-active',
+		editableSelector : ['table.editable'],
+		formClassName : 'editable-cell-form',
+		noEditClass : 'noedit',
+		editAjaxURI : '/',
+		editAjaxOptions : {},
+		observers : {
+			'onSortStart' 	: function(){},
+			'onSort' 		: function(){},
+			'onSortEnd' 	: function(){},
+			'onResizeStart' : function(){},
+			'onResize' 		: function(){},
+			'onResizeEnd' 	: function(){},
+			'onEditStart' 	: function(){},
+			'onEdit' 		: function(){},
+			'onEditEnd' 	: function(){}
+		}
+	},
+	_c : 0,
+	_getc : function() {return TableKit._c += 1;},
+	unloadTable : function(table){
+	  table = $(table);
+	  if(!TableKit.tables[table.id]) {return;} //if not an existing registered table return
+		var cells = TableKit.getHeaderCells(table);
+		var op = TableKit.option('sortable resizable editable noSortClass descendingClass ascendingClass columnClass sortFirstAscendingClass sortFirstDecendingClass', table.id);
+		 //unregister all the sorting and resizing events
+		cells.each(function(c){
+			c = $(c);
+			if(op.sortable) {
+  			if(!c.hasClassName(op.noSortClass)) {
+  				Event.stopObserving(c, 'mousedown', TableKit.Sortable._sort);
+  				c.removeClassName(op.columnClass);
+  				c.removeClassName(op.sortFirstAscendingClass);
+  				c.removeClassName(op.sortFirstDecendingClass);
+  				//ensure that if table reloaded current sort is remembered via sort first class name
+  				if(c.hasClassName(op.ascendingClass)) {
+  				  c.removeClassName(op.ascendingClass);
+  				  c.addClassName(op.sortFirstAscendingClass)
+  				} else if (c.hasClassName(op.descendingClass)) {
+  				  c.removeClassName(op.descendingClass);
+  				  c.addClassName(op.sortFirstDecendingClass)
+  				}
+  			}
+		  }
+		  if(op.resizable) {
+  			Event.stopObserving(c, 'mouseover', TableKit.Resizable.initDetect);
+  			Event.stopObserving(c, 'mouseout', TableKit.Resizable.killDetect);
+		  }
+		});
+		//unregister the editing events and cancel any open editors
+		if(op.editable) {
+		  Event.stopObserving(table.tBodies[0], 'click', TableKit.Editable._editCell);
+		  for(var c in TableKit.tables[table.id].dom.cells) {
+		    if(TableKit.tables[table.id].dom.cells[c].active) {
+		      var cell = $(c);
+  	      var editor = TableKit.Editable.getCellEditor(cell);
+  	      editor.cancel(cell);
+		    }
+  	  }
+		}
+		//delete the cache
+		TableKit.tables[table.id].dom = {head:null,rows:null,cells:{}}; // TODO: watch this for mem leaks
+	},
+	reloadTable : function(table){
+	  table = $(table);
+	  TableKit.unloadTable(table);
+	  var op = TableKit.option('sortable resizable editable', table.id);
+	  if(op.sortable) {TableKit.Sortable.init(table);}
+	  if(op.resizable) {TableKit.Resizable.init(table);}
+	  if(op.editable) {TableKit.Editable.init(table);}
+	},
+	reload : function() {
+	  for(var k in TableKit.tables) {
+	    TableKit.reloadTable(k);
+	  }
+	},
+	load : function() {
+		if(TableKit.options.autoLoad) {
+			if(TableKit.options.sortable) {
+				$A(TableKit.options.sortableSelector).each(function(s){
+					$$(s).each(function(t) {
+						TableKit.Sortable.init(t);
+					});
+				});
+			}
+			if(TableKit.options.resizable) {
+				$A(TableKit.options.resizableSelector).each(function(s){
+					$$(s).each(function(t) {
+						TableKit.Resizable.init(t);
+					});
+				});
+			}
+			if(TableKit.options.editable) {
+				$A(TableKit.options.editableSelector).each(function(s){
+					$$(s).each(function(t) {
+						TableKit.Editable.init(t);
+					});
+				});
+			}
+		}
+	}
+});
+
+TableKit.Rows = {
+	stripe : function(table) {
+		var rows = TableKit.getBodyRows(table);
+		rows.each(function(r,i) {
+			TableKit.Rows.addStripeClass(table,r,i);
+		});
+	},
+	addStripeClass : function(t,r,i) {
+		t = t || r.up('table');
+		var op = TableKit.option('rowEvenClass rowOddClass', t.id);
+		var css = ((i+1)%2 === 0 ? op[0] : op[1]);
+		// using prototype's assClassName/RemoveClassName was not efficient for large tables, hence:
+		var cn = r.className.split(/\s+/);
+		var newCn = [];
+		for(var x = 0, l = cn.length; x < l; x += 1) {
+			if(cn[x] !== op[0] && cn[x] !== op[1]) { newCn.push(cn[x]); }
+		}
+		newCn.push(css);
+		r.className = newCn.join(" ");
+	}
+};
+
+TableKit.Sortable = {
+	init : function(elm, options){
+		var table = $(elm);
+		if(table.tagName !== "TABLE") {
+			return;
+		}
+		TableKit.register(table,Object.extend(options || {},{sortable:true}));
+		var sortFirst;
+		var cells = TableKit.getHeaderCells(table);
+		var op = TableKit.option('noSortClass columnClass sortFirstAscendingClass sortFirstDecendingClass', table.id);
+		cells.each(function(c){
+			c = $(c);
+			if(!c.hasClassName(op.noSortClass)) {
+				Event.observe(c, 'mousedown', TableKit.Sortable._sort);
+				c.addClassName(op.columnClass);
+				if(c.hasClassName(op.sortFirstAscendingClass) || c.hasClassName(op.sortFirstDecendingClass)) {
+					sortFirst = c;
+				}
+			}
+		});
+
+		if(sortFirst) {
+			if(sortFirst.hasClassName(op.sortFirstAscendingClass)) {
+				TableKit.Sortable.sort(table, sortFirst, 1);
+			} else {
+				TableKit.Sortable.sort(table, sortFirst, -1);
+			}
+		} else { // just add row stripe classes
+			TableKit.Rows.stripe(table);
+		}
+	},
+	reload : function(table) {
+		table = $(table);
+		var cells = TableKit.getHeaderCells(table);
+		var op = TableKit.option('noSortClass columnClass', table.id);
+		cells.each(function(c){
+			c = $(c);
+			if(!c.hasClassName(op.noSortClass)) {
+				Event.stopObserving(c, 'mousedown', TableKit.Sortable._sort);
+				c.removeClassName(op.columnClass);
+			}
+		});
+		TableKit.Sortable.init(table);
+	},
+	_sort : function(e) {
+		if(TableKit.Resizable._onHandle) {return;}
+		e = TableKit.e(e);
+		Event.stop(e);
+		var cell = Event.element(e);
+		while(!(cell.tagName && cell.tagName.match(/td|th/gi))) {
+			cell = cell.parentNode;
+		}
+		TableKit.Sortable.sort(null, cell);
+	},
+	sort : function(table, index, order) {
+		var cell;
+		if(typeof index === 'number') {
+			if(!table || (table.tagName && table.tagName !== "TABLE")) {
+				return;
+			}
+			table = $(table);
+			index = Math.min(table.rows[0].cells.length, index);
+			index = Math.max(1, index);
+			index -= 1;
+			cell = (table.tHead && table.tHead.rows.length > 0) ? $(table.tHead.rows[table.tHead.rows.length-1].cells[index]) : $(table.rows[0].cells[index]);
+		} else {
+			cell = $(index);
+			table = table ? $(table) : cell.up('table');
+			index = TableKit.getCellIndex(cell);
+		}
+		var op = TableKit.option('noSortClass descendingClass ascendingClass defaultSortDirection', table.id);
+
+		if(cell.hasClassName(op.noSortClass)) {return;}
+		//TableKit.notify('onSortStart', table);
+		order = order ? order : op.defaultSortDirection;
+		var rows = TableKit.getBodyRows(table);
+
+		if(cell.hasClassName(op.ascendingClass) || cell.hasClassName(op.descendingClass)) {
+			rows.reverse(); // if it was already sorted we just need to reverse it.
+			order = cell.hasClassName(op.descendingClass) ? 1 : -1;
+		} else {
+			var datatype = TableKit.Sortable.getDataType(cell,index,table);
+			var tkst = TableKit.Sortable.types;
+			rows.sort(function(a,b) {
+				return order * tkst[datatype].compare(TableKit.getCellText(a.cells[index]),TableKit.getCellText(b.cells[index]));
+			});
+		}
+		var tb = table.tBodies[0];
+		var tkr = TableKit.Rows;
+		rows.each(function(r,i) {
+			tb.appendChild(r);
+			tkr.addStripeClass(table,r,i);
+		});
+		var hcells = TableKit.getHeaderCells(null, cell);
+		$A(hcells).each(function(c,i){
+			c = $(c);
+			c.removeClassName(op.ascendingClass);
+			c.removeClassName(op.descendingClass);
+			if(index === i) {
+				if(order === 1) {
+					c.addClassName(op.ascendingClass);
+				} else {
+					c.addClassName(op.descendingClass);
+				}
+			}
+		});
+	},
+	types : {},
+	detectors : [],
+	addSortType : function() {
+		$A(arguments).each(function(o){
+			TableKit.Sortable.types[o.name] = o;
+		});
+	},
+	getDataType : function(cell,index,table) {
+		cell = $(cell);
+		index = (index || index === 0) ? index : TableKit.getCellIndex(cell);
+
+		var colcache = TableKit.Sortable._coltypecache;
+		var cache = colcache[table.id] ? colcache[table.id] : (colcache[table.id] = {});
+
+		if(!cache[index]) {
+			var t = false;
+			// first look for a data type id on the heading row cell
+			if(cell.id && TableKit.Sortable.types[cell.id]) {
+				t = cell.id
+			}
+			if(!t) {
+  			t = $w(cell.className).detect(function(n){ // then look for a data type classname on the heading row cell
+  				return (TableKit.Sortable.types[n]) ? true : false;
+  			});
+			}
+			if(!t) {
+				var rows = TableKit.getBodyRows(table);
+				cell = rows[0].cells[index]; // grab same index cell from body row to try and match data type
+				t = TableKit.Sortable.detectors.detect(
+						function(d){
+							return TableKit.Sortable.types[d].detect(TableKit.getCellText(cell));
+						});
+			}
+			cache[index] = t;
+		}
+		return cache[index];
+	},
+	_coltypecache : {}
+};
+
+TableKit.Sortable.detectors = $A($w('date-iso date date-eu date-au time currency datasize number casesensitivetext text')); // setting it here because Safari complained when I did it above...
+
+TableKit.Sortable.Type = Class.create();
+TableKit.Sortable.Type.prototype = {
+	initialize : function(name, options){
+		this.name = name;
+		options = Object.extend({
+			normal : function(v){
+				return v;
+			},
+			pattern : /.*/
+		}, options || {});
+		this.normal = options.normal;
+		this.pattern = options.pattern;
+		if(options.compare) {
+			this.compare = options.compare;
+		}
+		if(options.detect) {
+			this.detect = options.detect;
+		}
+	},
+	compare : function(a,b){
+		return TableKit.Sortable.Type.compare(this.normal(a), this.normal(b));
+	},
+	detect : function(v){
+		return this.pattern.test(v);
+	}
+};
+
+TableKit.Sortable.Type.compare = function(a,b) {
+	return a < b ? -1 : a === b ? 0 : 1;
+};
+
+TableKit.Sortable.addSortType(
+	new TableKit.Sortable.Type('number', {
+		pattern : /^[-+]?[\d]*\.?[\d]+(?:[eE][-+]?[\d]+)?/,
+		normal : function(v) {
+			// This will grab the first thing that looks like a number from a string, so you can use it to order a column of various srings containing numbers.
+			v = parseFloat(v.replace(/^.*?([-+]?[\d]*\.?[\d]+(?:[eE][-+]?[\d]+)?).*$/,"$1"));
+			return isNaN(v) ? 0 : v;
+		}}),
+	new TableKit.Sortable.Type('text',{
+		normal : function(v) {
+			return v ? v.toLowerCase() : '';
+		}}),
+	new TableKit.Sortable.Type('casesensitivetext',{pattern : /^[A-Z]+$/}),
+	new TableKit.Sortable.Type('datasize',{
+		pattern : /^[-+]?[\d]*\.?[\d]+(?:[eE][-+]?[\d]+)?\s?[k|m|g|t]b$/i,
+		normal : function(v) {
+			var r = v.match(/^([-+]?[\d]*\.?[\d]+([eE][-+]?[\d]+)?)\s?([k|m|g|t]?b)?/i);
+			var b = r[1] ? Number(r[1]).valueOf() : 0;
+			var m = r[3] ? r[3].substr(0,1).toLowerCase() : '';
+			var result = b;
+			switch(m) {
+				case  'k':
+					result = b * 1024;
+					break;
+				case  'm':
+					result = b * 1024 * 1024;
+					break;
+				case  'g':
+					result = b * 1024 * 1024 * 1024;
+					break;
+				case  't':
+					result = b * 1024 * 1024 * 1024 * 1024;
+					break;
+			}
+			return result;
+		}}),
+	new TableKit.Sortable.Type('date-au',{
+		pattern : /^\d{2}\/\d{2}\/\d{4}\s?(?:\d{1,2}\:\d{2}(?:\:\d{2})?\s?[a|p]?m?)?/i,
+		normal : function(v) {
+			if(!this.pattern.test(v)) {return 0;}
+			var r = v.match(/^(\d{2})\/(\d{2})\/(\d{4})\s?(?:(\d{1,2})\:(\d{2})(?:\:(\d{2}))?\s?([a|p]?m?))?/i);
+			var yr_num = r[3];
+			var mo_num = parseInt(r[2],10)-1;
+			var day_num = r[1];
+			var hr_num = r[4] ? r[4] : 0;
+			if(r[7]) {
+				var chr = parseInt(r[4],10);
+				if(r[7].toLowerCase().indexOf('p') !== -1) {
+					hr_num = chr < 12 ? chr + 12 : chr;
+				} else if(r[7].toLowerCase().indexOf('a') !== -1) {
+					hr_num = chr < 12 ? chr : 0;
+				}
+			}
+			var min_num = r[5] ? r[5] : 0;
+			var sec_num = r[6] ? r[6] : 0;
+			return new Date(yr_num, mo_num, day_num, hr_num, min_num, sec_num, 0).valueOf();
+		}}),
+	new TableKit.Sortable.Type('date-us',{
+		pattern : /^\d{2}\/\d{2}\/\d{4}\s?(?:\d{1,2}\:\d{2}(?:\:\d{2})?\s?[a|p]?m?)?/i,
+		normal : function(v) {
+			if(!this.pattern.test(v)) {return 0;}
+			var r = v.match(/^(\d{2})\/(\d{2})\/(\d{4})\s?(?:(\d{1,2})\:(\d{2})(?:\:(\d{2}))?\s?([a|p]?m?))?/i);
+			var yr_num = r[3];
+			var mo_num = parseInt(r[1],10)-1;
+			var day_num = r[2];
+			var hr_num = r[4] ? r[4] : 0;
+			if(r[7]) {
+				var chr = parseInt(r[4],10);
+				if(r[7].toLowerCase().indexOf('p') !== -1) {
+					hr_num = chr < 12 ? chr + 12 : chr;
+				} else if(r[7].toLowerCase().indexOf('a') !== -1) {
+					hr_num = chr < 12 ? chr : 0;
+				}
+			}
+			var min_num = r[5] ? r[5] : 0;
+			var sec_num = r[6] ? r[6] : 0;
+			return new Date(yr_num, mo_num, day_num, hr_num, min_num, sec_num, 0).valueOf();
+		}}),
+	new TableKit.Sortable.Type('date-eu',{
+		pattern : /^\d{2}-\d{2}-\d{4}/i,
+		normal : function(v) {
+			if(!this.pattern.test(v)) {return 0;}
+			var r = v.match(/^(\d{2})-(\d{2})-(\d{4})/);
+			var yr_num = r[3];
+			var mo_num = parseInt(r[2],10)-1;
+			var day_num = r[1];
+			return new Date(yr_num, mo_num, day_num).valueOf();
+		}}),
+	new TableKit.Sortable.Type('date-iso',{
+		pattern : /[\d]{4}-[\d]{2}-[\d]{2}(?:T[\d]{2}\:[\d]{2}(?:\:[\d]{2}(?:\.[\d]+)?)?(Z|([-+][\d]{2}:[\d]{2})?)?)?/, // 2005-03-26T19:51:34Z
+		normal : function(v) {
+			if(!this.pattern.test(v)) {return 0;}
+		    var d = v.match(/([\d]{4})(-([\d]{2})(-([\d]{2})(T([\d]{2}):([\d]{2})(:([\d]{2})(\.([\d]+))?)?(Z|(([-+])([\d]{2}):([\d]{2})))?)?)?)?/);
+		    var offset = 0;
+		    var date = new Date(d[1], 0, 1);
+		    if (d[3]) { date.setMonth(d[3] - 1) ;}
+		    if (d[5]) { date.setDate(d[5]); }
+		    if (d[7]) { date.setHours(d[7]); }
+		    if (d[8]) { date.setMinutes(d[8]); }
+		    if (d[10]) { date.setSeconds(d[10]); }
+		    if (d[12]) { date.setMilliseconds(Number("0." + d[12]) * 1000); }
+		    if (d[14]) {
+		        offset = (Number(d[16]) * 60) + Number(d[17]);
+		        offset *= ((d[15] === '-') ? 1 : -1);
+		    }
+		    offset -= date.getTimezoneOffset();
+		    if(offset !== 0) {
+		    	var time = (Number(date) + (offset * 60 * 1000));
+		    	date.setTime(Number(time));
+		    }
+			return date.valueOf();
+		}}),
+	new TableKit.Sortable.Type('date',{
+		pattern: /^(?:sun|mon|tue|wed|thu|fri|sat)\,\s\d{1,2}\s(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s\d{4}(?:\s\d{2}\:\d{2}(?:\:\d{2})?(?:\sGMT(?:[+-]\d{4})?)?)?/i, //Mon, 18 Dec 1995 17:28:35 GMT
+		compare : function(a,b) { // must be standard javascript date format
+			if(a && b) {
+				return TableKit.Sortable.Type.compare(new Date(a),new Date(b));
+			} else {
+				return TableKit.Sortable.Type.compare(a ? 1 : 0, b ? 1 : 0);
+			}
+		}}),
+	new TableKit.Sortable.Type('time',{
+		pattern : /^\d{1,2}\:\d{2}(?:\:\d{2})?(?:\s[a|p]m)?$/i,
+		compare : function(a,b) {
+			var d = new Date();
+			var ds = d.getMonth() + "/" + d.getDate() + "/" + d.getFullYear() + " ";
+			return TableKit.Sortable.Type.compare(new Date(ds + a),new Date(ds + b));
+		}}),
+	new TableKit.Sortable.Type('currency',{
+		pattern : /^[$����]/, // dollar,pound,yen,euro,generic currency symbol
+		normal : function(v) {
+			return v ? parseFloat(v.replace(/[^-\d\.]/g,'')) : 0;
+		}})
+);
+
+TableKit.Resizable = {
+	init : function(elm, options){
+		var table = $(elm);
+		if(table.tagName !== "TABLE") {return;}
+		TableKit.register(table,Object.extend(options || {},{resizable:true}));
+		var cells = TableKit.getHeaderCells(table);
+		cells.each(function(c){
+			c = $(c);
+			Event.observe(c, 'mouseover', TableKit.Resizable.initDetect);
+			Event.observe(c, 'mouseout', TableKit.Resizable.killDetect);
+		});
+	},
+	resize : function(table, index, w) {
+		var cell;
+		if(typeof index === 'number') {
+			if(!table || (table.tagName && table.tagName !== "TABLE")) {return;}
+			table = $(table);
+			index = Math.min(table.rows[0].cells.length, index);
+			index = Math.max(1, index);
+			index -= 1;
+			cell = (table.tHead && table.tHead.rows.length > 0) ? $(table.tHead.rows[table.tHead.rows.length-1].cells[index]) : $(table.rows[0].cells[index]);
+		} else {
+			cell = $(index);
+			table = table ? $(table) : cell.up('table');
+			index = TableKit.getCellIndex(cell);
+		}
+		var pad = parseInt(cell.getStyle('paddingLeft'),10) + parseInt(cell.getStyle('paddingRight'),10);
+		w = Math.max(w-pad, TableKit.option('minWidth', table.id)[0]);
+
+		cell.setStyle({'width' : w + 'px'});
+	},
+	initDetect : function(e) {
+		e = TableKit.e(e);
+		var cell = Event.element(e);
+		Event.observe(cell, 'mousemove', TableKit.Resizable.detectHandle);
+		Event.observe(cell, 'mousedown', TableKit.Resizable.startResize);
+	},
+	detectHandle : function(e) {
+		e = TableKit.e(e);
+		var cell = Event.element(e);
+  		if(TableKit.Resizable.pointerPos(cell,Event.pointerX(e),Event.pointerY(e))){
+  			cell.addClassName(TableKit.option('resizeOnHandleClass', cell.up('table').id)[0]);
+  			TableKit.Resizable._onHandle = true;
+  		} else {
+  			cell.removeClassName(TableKit.option('resizeOnHandleClass', cell.up('table').id)[0]);
+  			TableKit.Resizable._onHandle = false;
+  		}
+	},
+	killDetect : function(e) {
+		e = TableKit.e(e);
+		TableKit.Resizable._onHandle = false;
+		var cell = Event.element(e);
+		Event.stopObserving(cell, 'mousemove', TableKit.Resizable.detectHandle);
+		Event.stopObserving(cell, 'mousedown', TableKit.Resizable.startResize);
+		cell.removeClassName(TableKit.option('resizeOnHandleClass', cell.up('table').id)[0]);
+	},
+	startResize : function(e) {
+		e = TableKit.e(e);
+		if(!TableKit.Resizable._onHandle) {return;}
+		var cell = Event.element(e);
+		Event.stopObserving(cell, 'mousemove', TableKit.Resizable.detectHandle);
+		Event.stopObserving(cell, 'mousedown', TableKit.Resizable.startResize);
+		Event.stopObserving(cell, 'mouseout', TableKit.Resizable.killDetect);
+		TableKit.Resizable._cell = cell;
+		var table = cell.up('table');
+		TableKit.Resizable._tbl = table;
+		if(TableKit.option('showHandle', table.id)[0]) {
+			TableKit.Resizable._handle = $(document.createElement('div')).addClassName('resize-handle').setStyle({
+				'top' : cell.cumulativeOffset()[1] + 'px',
+				'left' : Event.pointerX(e) + 'px',
+				'height' : table.getDimensions().height + 'px'
+			});
+			document.body.appendChild(TableKit.Resizable._handle);
+		}
+		Event.observe(document, 'mousemove', TableKit.Resizable.drag);
+		Event.observe(document, 'mouseup', TableKit.Resizable.endResize);
+		Event.stop(e);
+	},
+	endResize : function(e) {
+		e = TableKit.e(e);
+		var cell = TableKit.Resizable._cell;
+		TableKit.Resizable.resize(null, cell, (Event.pointerX(e) - cell.cumulativeOffset()[0]));
+		Event.stopObserving(document, 'mousemove', TableKit.Resizable.drag);
+		Event.stopObserving(document, 'mouseup', TableKit.Resizable.endResize);
+		if(TableKit.option('showHandle', TableKit.Resizable._tbl.id)[0]) {
+			$$('div.resize-handle').each(function(elm){
+				document.body.removeChild(elm);
+			});
+		}
+		Event.observe(cell, 'mouseout', TableKit.Resizable.killDetect);
+		TableKit.Resizable._tbl = TableKit.Resizable._handle = TableKit.Resizable._cell = null;
+		Event.stop(e);
+	},
+	drag : function(e) {
+		e = TableKit.e(e);
+		if(TableKit.Resizable._handle === null) {
+			try {
+				TableKit.Resizable.resize(TableKit.Resizable._tbl, TableKit.Resizable._cell, (Event.pointerX(e) - TableKit.Resizable._cell.cumulativeOffset()[0]));
+			} catch(e) {}
+		} else {
+			TableKit.Resizable._handle.setStyle({'left' : Event.pointerX(e) + 'px'});
+		}
+		return false;
+	},
+	pointerPos : function(element, x, y) {
+    	var offset = $(element).cumulativeOffset();
+	    return (y >= offset[1] &&
+	            y <  offset[1] + element.offsetHeight &&
+	            x >= offset[0] + element.offsetWidth - 5 &&
+	            x <  offset[0] + element.offsetWidth);
+  	},
+	_onHandle : false,
+	_cell : null,
+	_tbl : null,
+	_handle : null
+};
+
+
+TableKit.Editable = {
+	init : function(elm, options){
+		var table = $(elm);
+		if(table.tagName !== "TABLE") {return;}
+		TableKit.register(table,Object.extend(options || {},{editable:true}));
+		Event.observe(table.tBodies[0], 'click', TableKit.Editable._editCell);
+		Event.observe(table.tHead, 'click', TableKit.Editable._editCell);
+	},
+	_editCell : function(e) {
+		e = TableKit.e(e);
+		var cell = Event.findElement(e,'td') || Event.findElement(e,'th');
+		if (Event.findElement(e,'a')) {
+		  return false;
+		}
+		if(cell) {
+			TableKit.Editable.editCell(null, cell, null, e);
+		} else {
+			return false;
+		}
+	},
+	editCell : function(table, index, cindex, event) {
+		var cell, row;
+		if(typeof index === 'number') {
+			if(!table || (table.tagName && table.tagName !== "TABLE")) {return;}
+			table = $(table);
+			index = Math.min(table.tBodies[0].rows.length, index);
+			index = Math.max(1, index);
+			index -= 1;
+			cindex = Math.min(table.rows[0].cells.length, cindex);
+			cindex = Math.max(1, cindex);
+			cindex -= 1;
+			row = $(table.tBodies[0].rows[index]);
+			cell = $(row.cells[cindex]);
+		} else {
+			cell = $(event ? (Event.findElement(event, 'td') || Event.findElement(event, 'th')) : index);
+			table = (table && table.tagName && table.tagName !== "TABLE") ? $(table) : cell.up('table');
+			row = cell.up('tr');
+		}
+		var op = TableKit.option('noEditClass', table.id);
+		if(cell.hasClassName(op.noEditClass)) {return;}
+
+		var head = $(TableKit.getHeaderCells(table, cell)[TableKit.getCellIndex(cell)]);
+		if(head.hasClassName(op.noEditClass)) {return;}
+
+		var data = TableKit.getCellData(cell);
+		if(data.active) {return;}
+		data.htmlContent = cell.innerHTML;
+		var ftype = TableKit.Editable.getCellEditor(cell,null,head,event);
+		ftype.edit(cell, event);
+		data.active = true;
+	},
+	getCellEditor : function(cell, table, head, event) {
+	  // cannot use cell.select('p'). Why ???
+	  var head = head ? head : $(TableKit.getHeaderCells(table, cell)[TableKit.getCellIndex(cell)]);
+	  var ftype = (head !== cell && event && (event.shiftKey || cell.getElementsByTagName('p')[0])) ? TableKit.Editable.types['multi-line-input'] : TableKit.Editable.types['text-input'];
+		if(head.id && TableKit.Editable.types[head.id]) {
+			ftype = TableKit.Editable.types[head.id];
+		} else {
+			var n = $w(head.className).detect(function(n){
+					return (TableKit.Editable.types[n]) ? true : false;
+			});
+			ftype = n ? TableKit.Editable.types[n] : ftype;
+		}
+		return ftype;
+	},
+	types : {},
+	addCellEditor : function(o) {
+		if(o && o.name) { TableKit.Editable.types[o.name] = o; }
+	}
+};
+
+TableKit.Editable.CellEditor = Class.create();
+TableKit.Editable.CellEditor.prototype = {
+	initialize : function(name, options){
+		this.name = name;
+		this.options = Object.extend({
+			element : 'input',
+			attributes : {name : 'value', type : 'text'},
+			selectOptions : [],
+			showSubmit : true,
+			submitText : 'OK',
+			showCancel : true,
+			cancelText : 'Cancel',
+			ajaxURI : null,
+			ajaxOptions : null
+		}, options || {});
+	},
+	edit : function(cell) {
+	  this.getCellText(cell);
+  },
+  getCellText : function(cell) {
+    if(!cell) { return ""; }
+		var row = cell.up('tr');
+		var table = cell.up('table');
+		var dom_id  = table.id;
+		var attr    = dom_id.replace(/^\d+_/,'');
+		var node_id = dom_id.match(/^\d+/);
+		var url = '/nodes/' + node_id + '/cell_edit?row=' + TableKit.getRowIndex(row) + '&cell=' + TableKit.getCellIndex(cell) + '&attr=' + attr;
+		var editor = this;
+		new Ajax.Request(url, {
+		  method:'get',
+		  onSuccess: function(transport) {
+         var data = transport.responseText;
+         editor.showForm(cell,data);
+    }});
+  },
+  showForm : function(cell, txt) {
+		cell = $(cell);
+
+		var op = this.options;
+		var element = txt.match(/\n/) ? 'textarea' : op.element;
+		var table = cell.up('table');
+
+		var form = $(document.createElement("form"));
+		form.id = cell.id + '-form';
+		form.addClassName(TableKit.option('formClassName', table.id)[0]);
+		form.onsubmit = this._submit.bindAsEventListener(this);
+
+		var field = document.createElement(element);
+			$H(op.attributes).each(function(v){
+				field[v.key] = v.value;
+			});
+			switch(element) {
+				case 'input':
+				case 'textarea':
+				field.value = txt;
+				break;
+
+				case 'select':
+				$A(op.selectOptions).each(function(v){
+					field.options[field.options.length] = new Option(v[0], v[1]);
+					if(txt === v[1]) {
+						field.options[field.options.length-1].selected = 'selected';
+					}
+				});
+				break;
+			}
+			form.appendChild(field);
+			if(element === 'textarea') {
+				form.appendChild(document.createElement("br"));
+				var okButton = document.createElement("input");
+				okButton.type = "submit";
+				okButton.value = op.submitText;
+				okButton.className = 'editor_ok_button';
+				form.appendChild(okButton);
+			}
+			//if(op.showCancel) {
+			//	var cancelLink = document.createElement("a");
+			//	cancelLink.href = "#";
+			//	cancelLink.appendChild(document.createTextNode(op.cancelText));
+			//	cancelLink.onclick = this._cancel.bindAsEventListener(this);
+			//	cancelLink.className = 'editor_cancel';
+			//	form.appendChild(cancelLink);
+			//}
+			cell.innerHTML = '';
+			cell.appendChild(form);
+			form.focusFirstElement();
+	},
+	_submit : function(e) {
+		var cell = Event.findElement(e,'td') || Event.findElement(e,'th');
+		var form = Event.findElement(e,'form');
+		Event.stop(e);
+		this.submit(cell,form);
+	},
+	submit : function(cell, form) {
+		var op = this.options;
+		form = form ? form : cell.down('form');
+		var head = $(TableKit.getHeaderCells(null, cell)[TableKit.getCellIndex(cell)]);
+		var row = cell.up('tr');
+		var table = cell.up('table');
+		var dom_id  = table.id;
+		var attr    = dom_id.replace(/^\d+_/,'');
+		var node_id = dom_id.match(/^\d+/);
+		var s = '&row=' + TableKit.getRowIndex(row) + '&cell=' + TableKit.getCellIndex(cell) + '&attr=' + attr + '&' + Form.serialize(form);
+		this.ajax = new Ajax.Updater(cell, '/nodes/' + node_id + '/cell_update', Object.extend(op.ajaxOptions || TableKit.option('editAjaxOptions', table.id)[0], {
+			postBody : s,
+			onComplete : function() {
+				var data = TableKit.getCellData(cell);
+				data.active = false;
+				data.refresh = true; // mark cell cache for refreshing, in case cell contents has changed and sorting is applied
+			}
+		}));
+	},
+	_cancel : function(e) {
+		var cell = Event.findElement(e,'td') || Event.findElement(e,'th');
+		Event.stop(e);
+		this.cancel(cell);
+	},
+	cancel : function(cell) {
+		this.ajax = null;
+		var data = TableKit.getCellData(cell);
+		cell.innerHTML = data.htmlContent;
+		data.htmlContent = '';
+		data.active = false;
+	},
+	ajax : null
+};
+
+TableKit.Editable.textInput = function(n,attributes) {
+	TableKit.Editable.addCellEditor(new TableKit.Editable.CellEditor(n, {
+		element : 'input',
+		attributes : Object.extend({name : 'value', type : 'text'}, attributes||{})
+	}));
+};
+TableKit.Editable.textInput('text-input');
+
+TableKit.Editable.multiLineInput = function(n,attributes) {
+	TableKit.Editable.addCellEditor(new TableKit.Editable.CellEditor(n, {
+		element : 'textarea',
+		attributes : Object.extend({name : 'value', rows : '5', cols : '20'}, attributes||{})
+	}));
+};
+TableKit.Editable.multiLineInput('multi-line-input');
+
+TableKit.Editable.selectInput = function(n,attributes,selectOptions) {
+	TableKit.Editable.addCellEditor(new TableKit.Editable.CellEditor(n, {
+		element : 'select',
+		attributes : Object.extend({name : 'value'}, attributes||{}),
+		'selectOptions' : selectOptions
+	}));
+};
+
+/*
+TableKit.Bench = {
+	bench : [],
+	start : function(){
+		TableKit.Bench.bench[0] = new Date().getTime();
+	},
+	end : function(s){
+		TableKit.Bench.bench[1] = new Date().getTime();
+		alert(s + ' ' + ((TableKit.Bench.bench[1]-TableKit.Bench.bench[0])/1000)+' seconds.') //console.log(s + ' ' + ((TableKit.Bench.bench[1]-TableKit.Bench.bench[0])/1000)+' seconds.')
+		TableKit.Bench.bench = [];
+	}
+} */
+
+document.observe("dom:loaded", TableKit.load);