prototype.js

应用泛型以及反射编写的单表操作框架

	removeClassName: function(element, className) {
		if (!(element = $(element))) return;
		Element.classNames(element).remove(className);
		return element;
	},

	observe: function() {
		Event.observe.apply(Event, arguments);
		return $A(arguments).first();
	},

	stopObserving: function() {
		Event.stopObserving.apply(Event, arguments);
		return $A(arguments).first();
	},

// removes whitespace-only text node children
	cleanWhitespace: function(element) {
		element = $(element);
		for (var i = 0; i < element.childNodes.length; i++) {
			var node = element.childNodes[i];
			if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
				Element.remove(node);
		}
		return element;
	},

	empty: function(element) {
		return $(element).innerHTML.match(/^\s*$/);
	},

	childOf: function(element, ancestor) {
		element = $(element),ancestor = $(ancestor);
		while (element = element.parentNode)
			if (element == ancestor) return true;
		return false;
	},

	scrollTo: function(element) {
		element = $(element);
		var x = element.x ? element.x : element.offsetLeft,
				y = element.y ? element.y : element.offsetTop;
		window.scrollTo(x, y);
		return element;
	},

	getStyle: function(element, style) {
		element = $(element);
		var value = element.style[style.camelize()];
		if (!value) {
			if (document.defaultView && document.defaultView.getComputedStyle) {
				var css = document.defaultView.getComputedStyle(element, null);
				value = css ? css.getPropertyValue(style) : null;
			} else if (element.currentStyle) {
				value = element.currentStyle[style.camelize()];
			}
		}

		if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
			if (Element.getStyle(element, 'position') == 'static') value = 'auto';

		return value == 'auto' ? null : value;
	},

	setStyle: function(element, style) {
		element = $(element);
		for (var name in style)
			element.style[name.camelize()] = style[name];
		return element;
	},

	getDimensions: function(element) {
		element = $(element);
		if (Element.getStyle(element, 'display') != 'none')
			return {width: element.offsetWidth, height: element.offsetHeight};

		// All *Width and *Height properties give 0 on elements with display none,
		// so enable the element temporarily
		var els = element.style;
		var originalVisibility = els.visibility;
		var originalPosition = els.position;
		els.visibility = 'hidden';
		els.position = 'absolute';
		els.display = '';
		var originalWidth = element.clientWidth;
		var originalHeight = element.clientHeight;
		els.display = 'none';
		els.position = originalPosition;
		els.visibility = originalVisibility;
		return {width: originalWidth, height: originalHeight};
	},

	makePositioned: function(element) {
		element = $(element);
		var pos = Element.getStyle(element, 'position');
		if (pos == 'static' || !pos) {
			element._madePositioned = true;
			element.style.position = 'relative';
			// Opera returns the offset relative to the positioning context, when an
			// element is position relative but top and left have not been defined
			if (window.opera) {
				element.style.top = 0;
				element.style.left = 0;
			}
		}
		return element;
	},

	undoPositioned: function(element) {
		element = $(element);
		if (element._madePositioned) {
			element._madePositioned = undefined;
			element.style.position =
			element.style.top =
			element.style.left =
			element.style.bottom =
			element.style.right = '';
		}
		return element;
	},

	makeClipping: function(element) {
		element = $(element);
		if (element._overflow) return;
		element._overflow = element.style.overflow || 'auto';
		if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
			element.style.overflow = 'hidden';
		return element;
	},

	undoClipping: function(element) {
		element = $(element);
		if (!element._overflow) return;
		element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
		delete element._overflow;
		return element;
	}
}

// IE is missing .innerHTML support for TABLE-related elements
if (document.all) {
	Element.Methods.update = function(element, html) {
		element = $(element);
		var tagName = element.tagName.toUpperCase();
		if (['THEAD','TBODY','TR','TD'].indexOf(tagName) > -1) {
			var div = document.createElement('div');
			switch (tagName) {
				case 'THEAD':
				case 'TBODY':
					div.innerHTML = '<table><tbody>' + html.stripScripts() + '</tbody></table>';
					depth = 2;
					break;
				case 'TR':
					div.innerHTML = '<table><tbody><tr>' + html.stripScripts() + '</tr></tbody></table>';
					depth = 3;
					break;
				case 'TD':
					div.innerHTML = '<table><tbody><tr><td>' + html.stripScripts() + '</td></tr></tbody></table>';
					depth = 4;
			}
			$A(element.childNodes).each(function(node) {
				element.removeChild(node)
			});
			depth.times(function() {
				div = div.firstChild
			});

			$A(div.childNodes).each(
					function(node) {
						element.appendChild(node)
					});
		} else {
			element.innerHTML = html.stripScripts();
		}
		setTimeout(function() {
			html.evalScripts()
		}, 10);
		return element;
	}
}

Object.extend(Element, Element.Methods);

var _nativeExtensions = false;

if (!window.HTMLElement && /Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
	/* Emulate HTMLElement, HTMLFormElement, HTMLInputElement, HTMLTextAreaElement,
	and HTMLSelectElement in Safari */
	['', 'Form', 'Input', 'TextArea', 'Select'].each(function(tag) {
		var klass = window['HTML' + tag + 'Element'] = {};
		klass.prototype = document.createElement(tag ? tag.toLowerCase() : 'div').__proto__;
	});
}

Element.addMethods = function(methods) {
	Object.extend(Element.Methods, methods || {});

	function copy(methods, destination) {
		var cache = Element.extend.cache;
		for (var property in methods) {
			var value = methods[property];
			destination[property] = cache.findOrStore(value);
		}
	}

	if (typeof HTMLElement != 'undefined') {
		copy(Element.Methods, HTMLElement.prototype);
		copy(Form.Methods, HTMLFormElement.prototype);
		[HTMLInputElement, HTMLTextAreaElement, HTMLSelectElement].each(function(klass) {
			copy(Form.Element.Methods, klass.prototype);
		});
		_nativeExtensions = true;
	}
}

var Toggle = new Object();
Toggle.display = Element.toggle;

/*--------------------------------------------------------------------------*/

Abstract.Insertion = function(adjacency) {
	this.adjacency = adjacency;
}

Abstract.Insertion.prototype = {
	initialize: function(element, content) {
		this.element = $(element);
		this.content = content.stripScripts();

		if (this.adjacency && this.element.insertAdjacentHTML) {
			try {
				this.element.insertAdjacentHTML(this.adjacency, this.content);
			} catch (e) {
				var tagName = this.element.tagName.toLowerCase();
				if (tagName == 'tbody' || tagName == 'tr') {
					this.insertContent(this.contentFromAnonymousTable());
				} else {
					throw e;
				}
			}
		} else {
			this.range = this.element.ownerDocument.createRange();
			if (this.initializeRange) this.initializeRange();
			this.insertContent([this.range.createContextualFragment(this.content)]);
		}

		setTimeout(function() {
			content.evalScripts()
		}, 10);
	},

	contentFromAnonymousTable: function() {
		var div = document.createElement('div');
		div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
		return $A(div.childNodes[0].childNodes[0].childNodes);
	}
}

var Insertion = new Object();

Insertion.Before = Class.create();
Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
	initializeRange: function() {
		this.range.setStartBefore(this.element);
	},

	insertContent: function(fragments) {
		fragments.each((function(fragment) {
			this.element.parentNode.insertBefore(fragment, this.element);
		}).bind(this));
	}
});

Insertion.Top = Class.create();
Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
	initializeRange: function() {
		this.range.selectNodeContents(this.element);
		this.range.collapse(true);
	},

	insertContent: function(fragments) {
		fragments.reverse(false).each((function(fragment) {
			this.element.insertBefore(fragment, this.element.firstChild);
		}).bind(this));
	}
});

Insertion.Bottom = Class.create();
Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
	initializeRange: function() {
		this.range.selectNodeContents(this.element);
		this.range.collapse(this.element);
	},

	insertContent: function(fragments) {
		fragments.each((function(fragment) {
			this.element.appendChild(fragment);
		}).bind(this));
	}
});

Insertion.After = Class.create();
Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
	initializeRange: function() {
		this.range.setStartAfter(this.element);
	},

	insertContent: function(fragments) {
		fragments.each((function(fragment) {
			this.element.parentNode.insertBefore(fragment,
					this.element.nextSibling);
		}).bind(this));
	}
});

/*--------------------------------------------------------------------------*/

Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
	initialize: function(element) {
		this.element = $(element);
	},

	_each: function(iterator) {
		this.element.className.split(/\s+/).select(function(name) {
			return name.length > 0;
		})._each(iterator);
	},

	set: function(className) {
		this.element.className = className;
	},

	add: function(classNameToAdd) {
		if (this.include(classNameToAdd)) return;
		this.set(this.toArray().concat(classNameToAdd).join(' '));
	},

	remove: function(classNameToRemove) {
		if (!this.include(classNameToRemove)) return;
		this.set(this.select(function(className) {
			return className != classNameToRemove;
		}).join(' '));
	},

	toString: function() {
		return this.toArray().join(' ');
	}
}

Object.extend(Element.ClassNames.prototype, Enumerable);
var Selector = Class.create();
Selector.prototype = {
	initialize: function(expression) {
		this.params = {classNames: []};
		this.expression = expression.toString().strip();
		this.parseExpression();
		this.compileMatcher();
	},

	parseExpression: function() {
		function abort(message) {
			throw 'Parse error in selector: ' + message;
		}

		if (this.expression == '')  abort('empty expression');

		var params = this.params, expr = this.expression, match, modifier, clause, rest;
		while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)) {
			params.attributes = params.attributes || [];
			params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
			expr = match[1];
		}

		if (expr == '*') return this.params.wildcard = true;

		while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+)(.*)/i)) {
			modifier = match[1],clause = match[2],rest = match[3];
			switch (modifier) {
				case '#':	   params.id = clause; break;
				case '.':	   params.classNames.push(clause); break;
				case '':
				case undefined: params.tagName = clause.toUpperCase(); break;
				default:		abort(expr.inspect());
			}
			expr = rest;
		}

		if (expr.length > 0) abort(expr.inspect());
	},

	buildMatchExpression: function() {
		var params = this.params, conditions = [], clause;

		if (params.wildcard)
			conditions.push('true');
		if (clause = params.id)
			conditions.push('element.id == ' + clause.inspect());
		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++)
				conditions.push('Element.hasClassName(element, ' + clause[i].inspect() + ')');
		if (clause = params.attributes) {
			clause.each(function(attribute) {
				var value = 'element.getAttribute(' + attribute.name.inspect() + ')';
				var splitValueBy = function(delimiter) {
					return value + ' && ' + value + '.split(' + delimiter.inspect() + ')';
				}

				switch (attribute.operator) {
					case '=':	   conditions.push(value + ' == ' + attribute.value.inspect()); break;
					case '~=':	  conditions.push(splitValueBy(' ') + '.include(' + attribute.value.inspect() + ')'); break;
					case '|=':	  conditions.push(
							splitValueBy('-') + '.first().toUpperCase() == ' + attribute.value.toUpperCase().inspect()
							); break;
					case '!=':	  conditions.push(value + ' != ' + attribute.value.inspect()); break;
					case '':
					case undefined: conditions.push(value + ' != null'); break;
					default:		throw 'Unknown operator ' + attribute.operator + ' in selector';
				}
			});
		}

		return conditions.join(' && ');
	},

	compileMatcher: function() {
		this.match = new Function('element', 'if (!element.tagName) return false; \
		return ' + this.buildMatchExpression());
	},

	findElements: function(scope) {
		var element;

		if (element = $(this.params.id))
			if (this.match(element))
				if (!scope || Element.childOf(element, scope))
					return [element];

		scope = (scope || document).getElementsByTagName(this.params.tagName || '*');

		var results = [];
		for (var i = 0; i < scope.length; i++)
			if (this.match(element = scope[i]))
				results.push(Element.extend(element));

		return results;
	},

	toString: function() {
		return this.expression;
	}
}

Object.extend(Selector, {
	matchElements: function(elements, expression) {
		var selector = new Selector(expression);
		return elements.select(selector.match.bind(selector));
	},

	findElement: function(elements, expression, index) {
		if (typeof expression == 'number') index = expression,expression = false;
		return Selector.matchElements(elements, expression || '*')[index || 0];
	},

	findChildElements: function(element, expressions) {
		return expressions.map(function(expression) {
			return expression.strip().split(/\s+/).inject([null], function(results, expr) {
				var selector = new Selector(expr);
				return results.inject([], function(elements, result) {
					return elements.concat(selector.findElements(result || element));
				});
			});
		}).flatten();
	}
});

function $$() {
	return Selector.findChildElements(document, $A(arguments));
}
var Form = {
	reset: function(form) {
		$(form).reset();
		return form;
	}
};

Form.Methods = {
	serialize: function(form) {
		var elements = Form.getElements($(form));
		var queryComponents = new Array();

		for (var i = 0; i < elements.length; i++) {
			var queryComponent = Form.Element.serialize(elements[i]);
			if (queryComponent)
				queryComponents.push(queryComponent);
		}

		return queryComponents.join('&');
	},

	getElements: function(form) {
		form = $(form);
		var elements = new Array();

		for (var tagName in Form.Element.Serializers) {
			var tagElements = form.getElementsByTagName(tagName);
			for (var j = 0; j < tagElements.length; j++)
				elements.push(tagElements[j]);
		}
		return elements;
	},

	getInputs: function(form, typeName, name) {
		form = $(form);
		var inputs = form.getElementsByTagName('input');

		if (!typeName && !name)
			return inputs;

		var matchingInputs = new Array();
		for (var i = 0; i < inputs.length; i++) {
			var input = inputs[i];
			if ((typeName && input.type != typeName) ||
				(name && input.name != name))
				continue;
			matchingInputs.push(input);
		}

		return matchingInputs;
	},

	disable: function(form) {
		form = $(form);
		var elements = Form.getElements(form);
		for (var i = 0; i < elements.length; i++) {
			var element = elements[i];
			element.blur();
			element.disabled = 'true';
		}
		return form;
	},

	enable: function(form) {
		form = $(form);
		var elements = Form.getElements(form);
		for (var i = 0; i < elements.length; i++) {
			var element = elements[i];
			element.disabled = '';
		}
		return form;
	},

	findFirstElement: function(form) {
		return Form.getElements(form).find(function(element) {
			return element.type != 'hidden' && !element.disabled &&
				   ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
		});
	},

	focusFirstElement: function(form) {
		form = $(form);
		Field.activate(Form.findFirstElement(form));
		return form;
	}
}

Object.extend(Form, Form.Methods);