【JavaScript 封装库】BETA 1.0 测试版发布！

/*
	源码作者: 石不易(Louis Shi)
	联系方式: http://www.shibuyi.net
	===================================================================================================
	程序名称: JavaScript 封装库 BETA 1.0 版
	迭代版本: Prototype
	功能总数: 44 个
	新增总数: 30 个
	删除总数: 0 个
	追加功能: 
		1. 元素隐藏与显示
		2. 表单 value 属性获取
		3. 实现 mouseover / mouseout / mousemove / mousedown / mouseup / scroll / resize / load / mousewheel 等事件
		4. 实现 元素居中 / 下拉菜单 / 元素拖拽 / 遮罩锁屏 / 禁止溢出 等特效
		...
	优化功能: 
		1. 实现元素节点直传
		2. 完善 id 多节点获取
		3. 完善 css 设置, 支持滤镜
		4. 完善 class 选择器, 支持多选择器添加和移除
		5. 完善 rule 样式规则, 支持多规则的添加和移除
		6. 实现二级子方法
		7. 实现代码分层至 Tool 工具库
		...
	删除功能: 
		无
*/

// 实例化封装库
function $(_this) {
	return new Base(_this);
}

// 封装库构造方法
function Base(_this) {
	this.elements = []; // 初始化元素列表
	if (typeof _this == 'object') this.elements.push(_this);
}

// 获取元素节点
Base.prototype.getNodes = function () {
	if (this.elements.length == 0) return '暂无任何元素节点';
	if (this.elements.length == 1) return this.elements[0];
	return this.elements;
};

// 获取 id 元素节点
Base.prototype.getId = function (id) {
	if (id instanceof Array) { // 集群
		for (var i = 0; i < id.length; i ++) {
			this.getId(id[i]);
		}
	} else { // 单个
		var node = {};
		node = document.getElementById(id);
		if (!node) return this;
		for (var i = 0; i < this.elements.length; i ++) {
			if (this.elements[i] == node) return this;
		}
		this.elements.push(node);
	}
	return this;
};

// 获取 name 元素节点
Base.prototype.getName = function (name, positionId) {
	var nodes = {};
	if (typeof positionId != 'undefined') { // 局部
		nodes = $().getTagName('*', positionId).getNodes();
	} else { // 全局
		nodes = document.getElementsByName(name);
	}
	for (var i = 0; i < nodes.length; i ++) {
		if (nodes[i].name == name) this.elements.push(nodes[i]);
	}
	return this;
};

// 获取 tagName 元素节点
Base.prototype.getTagName = function (tagName, positionId) {
	var nodes = {};
	if (typeof positionId != 'undefined') { // 局部
		nodes = $().getId(positionId).getNodes().getElementsByTagName(tagName);
	} else { // 全局
		nodes = document.getElementsByTagName(tagName);
	}
	for (var i = 0; i < nodes.length; i ++) {
		this.elements.push(nodes[i]);
	}
	return this;
};

// 获取 class 元素节点
Base.prototype.getClass = function (className, positionId) {
	var nodes = {}, results = [];
	if (typeof positionId != 'undefined') { // 局部
		nodes = $().getTagName('*', positionId);
		results = $().getClass.hasClass.call(nodes, className);
	} else { // 全局
		nodes = $().getTagName('*');
		results = $().getClass.hasClass.call(nodes, className);
	}
	nodes = nodes.getNodes();
	for (var i = 0; i < results.length; i ++) {
		if (results[i]) this.elements.push(nodes[i]);
	}
	return this;
};

// getClass 附属方法: 检测 class
Base.prototype.getClass.hasClass = function (className) {
	var results = [];
	for (var i = 0; i < this.elements.length; i ++) {
		results.push((new RegExp('(^|\\s+)' + className + '(\\s+|$)')).test(this.elements[i].className));
	}
	return results;
};

// 获取与设置 innerHTML(双标记)
Base.prototype.html = function (text) {
	if (typeof text != 'undefined') { // 设置
		for (var i = 0; i < this.elements.length; i ++) {
			this.elements[i].innerHTML = text;
		}
	} else { // 获取
		var html = [];
		for (var i = 0; i < this.elements.length; i ++) {
			html.push(this.elements[i].innerHTML);
		}
		if (html.length == 1) return html[0];
		return html;
	}
	return this;
};

// 获取与设置 value(表单)
Base.prototype.value = function (text) {
	if (typeof text != 'undefined') { // 设置
		for (var i = 0; i < this.elements.length; i ++) {
			if (typeof this.elements[i].value != 'undefined') this.elements[i].value = text;
		}
	} else { // 获取
		var value = [];
		for (var i = 0; i < this.elements.length; i ++) {
			if (typeof this.elements[i].value != 'undefined') value.push(this.elements[i].value);
		}
		if (value.length == 1) return value[0];
		return value;
	}
	return this;
};

// 获取与设置 CSS
Base.prototype.css = function (cssKey, cssValue) {
	if (typeof cssValue != 'undefined' || cssKey instanceof Array) { // 设置
		if (cssKey instanceof Array) { // 集群
			var _cssKey = '', _cssValue = '', pattern = /^\s*([a-z]+)\s*=\s*([\w#=\s\(\.\)\-\'\"\/\\]+)\s*$/i;
			for (var i = 0; i < cssKey.length; i ++) {
				if (pattern.test(cssKey[i])) {
					_cssKey = pattern.exec(cssKey[i])[1];
					_cssValue = pattern.exec(cssKey[i])[2];
					for (var j = 0; j < this.elements.length; j ++) {
						this.elements[j].style[_cssKey] = _cssValue;
					}
				}
			}
		} else { // 单个
			for (var i = 0; i < this.elements.length; i ++) {
				this.elements[i].style[cssKey] = cssValue;
			}
		}
	} else { // 获取
		var css = [], _cssValue = '';
		for (var i = 0; i < this.elements.length; i ++) {
			_cssValue = Tool.getStyle(this.elements[i], cssKey);
			if (typeof _cssValue != 'undefined') css.push(_cssValue);
		}
		if (css.length == 1) return css[0];
		return css;
	}
	return this;
};

// 添加 class
Base.prototype.addClass = function (className) {
	if (className instanceof Array) { // 集群
		for (var i = 0; i < className.length; i ++) {
			this.addClass(className[i]);
		}
	} else { // 单个
		var results = this.getClass.hasClass.call(this, className);
		var space = '';
		for (var i = 0; i < results.length; i ++) {
			if (this.elements[i].className != '') space = ' ';
			if (!results[i]) this.elements[i].className += space + className;
		}
	}
	return this;
};

// 移除 class
Base.prototype.removeClass = function (className) {
	if (className instanceof Array) { // 集群
		for (var i = 0; i < className.length; i ++) {
			this.removeClass(className[i]);
		}
	} else { // 单个
		var results = this.getClass.hasClass.call(this, className);
		for (var i = 0; i < results.length; i ++) {
			if (results[i]) this.elements[i].className = this.elements[i].className.replace(new RegExp('(^|\\s)' + className + '(\\s|$)'), '');
		}
	}
	return this;
};

// 添加 rule
Base.prototype.addRule = function (ruleName, ruleText, positionIndex, sheetIndex) {
	if (ruleName instanceof Array) { // 集群
		if (!ruleText instanceof Array || ruleName.length != ruleText.length) return this;
		for (var i = 0; i < ruleName.length; i ++) {
			this.addRule(ruleName[i], ruleText[i], positionIndex, sheetIndex);
		}
	} else { // 单个
		var rule = this.addRule.checkRule(positionIndex, sheetIndex);
		if (typeof rule.sheetObject != 'undefined') {
			if ((positionIndexMax = Tool.getRules(rule.sheetObject).length) < rule.positionIndex) rule.positionIndex = positionIndexMax;
			Tool.addRule(rule.sheetObject, ruleName, ruleText, rule.positionIndex);
		}
	}
	return this;
};

// addRule 附属方法: rule 容错处理
Base.prototype.addRule.checkRule = function (positionIndex, sheetIndex, positionLength) {
	if (typeof positionIndex == 'undefined' || isNaN(positionIndex)) positionIndex = 0;
	if (typeof sheetIndex == 'undefined' || isNaN(sheetIndex)) sheetIndex = 0;
	if (typeof positionLength == 'undefined' || isNaN(positionLength)) positionLength = 1;
	return {
		positionIndex : positionIndex,
		positionLength : positionLength,
		sheetObject : document.styleSheets[sheetIndex]
	}
};

// 删除 rule
Base.prototype.removeRule = function (positionIndex, positionLength, sheetIndex) {
	var rule = this.addRule.checkRule(positionIndex, sheetIndex, positionLength);
	if ((positionIndexMax = Tool.getRules(rule.sheetObject).length) <= rule.positionIndex || (positionIndexMax - rule.positionIndex) < rule.positionLength) return this;
	for (var i = 0; i < rule.positionLength; i ++) {
		Tool.removeRule(rule.sheetObject, rule.positionIndex);
	}
	return this;
};

// 显示元素
Base.prototype.show = function () {
	for (var i = 0; i < this.elements.length; i ++) {
		$(this.elements[i]).css('display', 'block');
	}
	return this;
};

// 隐藏元素
Base.prototype.hide = function () {
	for (var i = 0; i < this.elements.length; i ++) {
		$(this.elements[i]).css('display', 'none');
	}
	return this;
};

// 鼠标 click 事件
Base.prototype.click = function (method) {
	if (method instanceof Function) {
		for (var i = 0; i < this.elements.length; i ++) {
			this.elements[i].onclick = function (eventObject) {
				method.call(this, Tool.getEvent(eventObject));
			};
		}
	}
	return this;
};

// 鼠标 mouseover 事件
Base.prototype.mouseover = function (method) {
	if (method instanceof Function) {
		for (var i = 0; i < this.elements.length; i ++) {
			this.elements[i].onmouseover = function (eventObject) {
				method.call(this, Tool.getEvent(eventObject));
			};
		}
	}
	return this;
};

// 鼠标 mouseout 事件
Base.prototype.mouseout = function (method) {
	if (method instanceof Function) {
		for (var i = 0; i < this.elements.length; i ++) {
			this.elements[i].onmouseout = function (eventObject) {
				method.call(this, Tool.getEvent(eventObject));
			};
		}
	}
	return this;
};

// 鼠标 mousedown 事件
Base.prototype.mousedown = function (method) {
	if (method instanceof Function) {
		for (var i = 0; i < this.elements.length; i ++) {
			this.elements[i].onmousedown = function (eventObject) {
				method.call(this, Tool.getEvent(eventObject));
			};
		}
	}
	return this;
};

// 鼠标 mousemove 事件
Base.prototype.mousemove = function (method) {
	if (method instanceof Function) {
		for (var i = 0; i < this.elements.length; i ++) {
			this.elements[i].onmousemove = function (eventObject) {
				method.call(this, Tool.getEvent(eventObject));
			};
		}
	}
	return this;
};

// 鼠标 mouseup 事件
Base.prototype.mouseup = function (method) {
	if (method instanceof Function) {
		for (var i = 0; i < this.elements.length; i ++) {
			this.elements[i].onmouseup = function (eventObject) {
				method.call(this, Tool.getEvent(eventObject));
			};
		}
	}
	return this;
};

// 鼠标 mousewheel 事件
Base.prototype.mousewheel = function (method) {
	if (method instanceof Function) {
		for (var i = 0; i < this.elements.length; i ++) {
			Tool.mousewheelEvent(this.elements[i], method);
		}
	}
	return this;
};

// 元素 load 事件
Base.prototype.load = function (method) {
	if (method instanceof Function) {
		for (var i = 0; i < this.elements.length; i ++) {
			this.elements[i].onload = function (eventObject) {
				method.call(this, Tool.getEvent(eventObject));
			};
		}
	}
	return this;
};

// 元素 scroll 事件
Base.prototype.scroll = function (method) {
	if (method instanceof Function) {
		for (var i = 0; i < this.elements.length; i ++) {
			this.elements[i].onscroll = function (eventObject) {
				method.call(this, Tool.getEvent(eventObject));
			};
		}
	}
	return this;
};

// 窗口 resize 事件
Base.prototype.resize = function (method) {
	if (method instanceof Function) {
		window.onresize = function (eventObject) {
			method.call(this, Tool.getEvent(eventObject));
		};
	}
	return this;
};

// 鼠标 hover 特效
Base.prototype.hover = function (overMethod, outMethod) {
	this.mouseover(overMethod);
	this.mouseout(outMethod);
	return this;
};

// 元素居中显示特效
Base.prototype.center = function () {
	var innerRectangle = Tool.getInnerRectangle();
	var rectangle = {}, fixedX = 0, fixedY = 0, minX = 0, minY = 0, maxX = 0, maxY = 0;
	for (var i = 0; i < this.elements.length; i ++) {
		this.center.absolutePosition(this.elements[i]);
		rectangle = this.center.getRectangle(this.elements[i]);
		maxX = innerRectangle.innerWidth - rectangle.width;
		maxY = innerRectangle.innerHeight - rectangle.height;
		fixedX = maxX / 2;
		fixedY = maxY / 2;
		if (fixedX < minX) {
			fixedX = minX;
		} else if (fixedX > maxX) {
			fixedX = maxX;
		}
		if (fixedY < minY) {
			fixedY = minY;
		} else if (fixedY > maxY) {
			fixedY = maxY;
		}
		$(this.elements[i]).css(['left = ' + fixedX + 'px', 'top = ' + fixedY + 'px']);
	}
	return this;
};

// center 隶属方法: 获取元素长度
Base.prototype.center.getRectangle = function (elementNode) {
	var _this = $(elementNode);
	var width = _this.css('width');
	var height = _this.css('height');
	var display = _this.css('display');
	if (display != 'none' || width == 'auto' || height == 'auto') {
		_this.show();
		width = elementNode.offsetWidth;
		height = elementNode.offsetHeight;
	}
	width = this.split(width, 'px');
	height = this.split(height, 'px');
	return {
		width : width,
		height : height
	}
};

// center 隶属方法: 裁剪字符串
Base.prototype.center.split = function (string, pattern) {
	if (typeof string == 'string') {
		if (string.indexOf(pattern) != -1) string = string.replace(pattern, '');
	}
	return string;
};

// center 隶属方法: 元素设置绝对定位
Base.prototype.center.absolutePosition = function (elementNode) {
	if ($(elementNode).css('position') != 'absolute') {
		$(elementNode).css(['position = absolute', 'left = 0', 'top = 0']);
	}
};

// 屏幕遮罩特效: 锁屏
Base.prototype.lock = function () {
	var screenLock = $().getId('screen_lock').getNodes(); // 获取锁屏节点
	// 锁屏节点智能生成
	if (typeof screenLock == 'object') { // 存在
		this.lock.comment(screenLock); // 清除注释
		if (this.lock.trim($(screenLock).html()).length != 0) {
			this.lock.deleteElement('id = screen_lock');
			screenLock = this.lock.createElement('div', 'id = screen_lock');
		}
	} else { // 不存在
		screenLock = this.lock.createElement('div', 'id = screen_lock'); // 创建锁屏节点
	}
	
	$(document.documentElement).css('overflow', 'hidden');
	Tool.scrollInitialization();
	var innerRectangle = Tool.getInnerRectangle();
	this.center.absolutePosition(screenLock);
	var _this = $(screenLock);
	// 锁屏样式
	_this.css([
						'width = ' + innerRectangle.innerWidth + 'px', 
						'height = '  + innerRectangle.innerHeight +'px',
						'backgroundColor = black',
						'opacity = 0.4', // W3C 透明效果
						'filter = alpha(opacity = 40)', // IE 6/7/8 透明效果
						'zIndex = 10'
					]).show();
	// IE 6/7/8 与 Chrome 鼠标滚轮 BUG 处理
	_this.mousedown(function () { // 禁用 IE 6/7/8 鼠标默认行为
		_this.mousemove(function (eventObject) {
			Tool.preventEventDefault(eventObject);
		});
		_this.mouseup(function () {
			_this.mousedown(function () {
				return null;
			});
			_this.mouseup(function () {
				return null;
			});
		});
	});
	
	_this.mousewheel(function (eventObject) { // Chrome 禁用鼠标滚轮
		Tool.preventEventDefault(eventObject);
	});
	
	return this;
};

// 屏幕遮罩特效: 销锁
Base.prototype.unlock = function () {
	var screenLock = $().getId('screen_lock').getNodes();
	if (typeof screenLock == 'object') {
		$(screenLock).hide();
		$(document.documentElement).css('overflow', 'auto');
	}
	return this;
};

// lock 隶属方法: 匹配元素属性
Base.prototype.lock.matchAttribute = function (pattern, attribute, elementNode) {
	if (pattern.test(attribute)) {
		var attributeKey = pattern.exec(attribute)[1];
		var attributeValue = pattern.exec(attribute)[2];
		if (attributeKey == 'class') attributeKey = 'className';
		if (typeof elementNode == 'object') elementNode[attributeKey] = attributeValue;
		return {
			attributeKey : attributeKey,
			attributeValue : attributeValue
		}
	}
};

// lock 隶属方法: 创建元素
Base.prototype.lock.createElement = function (elementName, attribute, html, parentElement) {
	if (typeof parentElement == 'undefined') parentElement = document.body;
	var elementNode = document.createElement(elementName);
	if (typeof attribute != 'undefined') {
		var pattern = /^\s*([a-z]+)\s*=\s*([\w\-\s\.\\\/\=\(\)]+)\s*$/i;
		if (attribute instanceof Array) {
			for (var i = 0; i < attribute.length; i ++) {
				this.matchAttribute(pattern, attribute[i], elementNode);
			}
		} else {
			this.matchAttribute(pattern, attribute, elementNode);
		}
	}
	if (typeof html == 'string') {
		$(elementNode).html(html);
	}
	parentElement.appendChild(elementNode);
	return elementNode;
};

// lock 隶属方法: 删除元素
Base.prototype.lock.deleteElement = function (attribute) {
	if (typeof attribute != 'undefined') {
		if (attribute instanceof Array) {
			for (var i = 0; i < attribute.length; i ++) {
				this.deleteElement(attribute[i]);
			}
		} else {
			var pattern = /^\s*(id|class|className|name)\s*=\s*([\w\-\s\.\\\/\=\(\)]+)\s*$/i;
			var nodes = [], parentElement = {};
			if (pattern.test(attribute)) {
				arrtibuteObject = $().lock.matchAttribute(pattern, attribute);
				switch (arrtibuteObject.attributeKey) {
					case 'id' :
						nodes = $().getId(arrtibuteObject.attributeValue).getNodes();
						break;
						
					case 'name':
						nodes = $().getName(arrtibuteObject.attributeValue).getNodes();
						break;
						
					case 'className' :
						nodes = $().getClass(arrtibuteObject.attributeValue).getNodes();
						break;
				}
			} else { // tagName
				nodes = $().getTagName(attribute).getNodes();
			}
			if (nodes instanceof Array) {
				for (var i = 0; i < nodes.length; i ++) {
					parentElement = nodes[i].parentNode;
					if (typeof parentElement == 'undefined') continue;
					parentElement.removeChild(nodes[i]);
				}
			} else {
				parentElement = nodes.parentNode;
				if (typeof parentElement == 'undefined') return false;
				parentElement.removeChild(nodes);
			}
		}
	}
};

// lock 隶属方法: 清除字符串首位空格
Base.prototype.lock.trim = function (string) {
	var leftPattern = /^([\s　]+)/;
	var rightPattern = /([\s　]+)$/;
	if (leftPattern.test(string)) string = string.replace(leftPattern, '');
	if (rightPattern.test(string)) string = string.replace(rightPattern, '');
	return string;
};

// lock 隶属方法: 清除元素内部注释
Base.prototype.lock.comment = function (elementNode) {
	if (elementNode.id != '') var nodes = $().getTagName('!', elementNode.id).getNodes(); // IE 6/7/8
	if (typeof nodes != 'object') nodes = elementNode.childNodes; // W3C
	for (var i = 0; i < nodes.length; i ++) {
		if (nodes[i].nodeType == 8) elementNode.removeChild(nodes[i]);
	}
	return elementNode;
};

// lock 隶属方法: 清除元素内部空白文本节点
Base.prototype.lock.spaceNode = function (elementNode) {
	var nodes = elementNode.childNodes;
	for (var i = 0; i < nodes.length; i ++) {
		if (nodes[i].nodeType == 3 && /^([　\s]+)$/.test(nodes[i].nodeValue)) elementNode.removeChild(nodes[i]);
	}
	return elementNode;
};

// 元素拖拽特效
Base.prototype.drag = function (mode) {
	if (typeof mode == 'undefined') mode = true;
	this.mousedown(function (eventObject) {
		// 拖拽模式选择: true 拖拽元素自身、false 拖拽父级元素
		var _this = mode ? this : this.parentNode;
		
		$().lock.comment(_this);
		if ($().lock.trim($(_this).html()).length == 0) Tool.preventEventDefault(eventObject); // 兼容 Firefox 低版本拖拽 BUG
		
		// 设置绝对定位
		$().center.absolutePosition(_this);
		
		// 捕获鼠标当前坐标
		var mouseX = eventObject.clientX;
		var mouseY = eventObject.clientY;
		
		// 获取元素外边距
		var outerRectangle = $().drag.getOuterRectangle(_this);
		
		// 获取固定距离
		var fixedX = mouseX - outerRectangle.outerX;
		var fixedY = mouseY - outerRectangle.outerY;
		
		var innerRectangle = Tool.getInnerRectangle();
		var rectangle = $().center.getRectangle(_this);
		
		// 设置容错距离
		var minX = 0, minY = 0, maxX = 0, maxY = 0;
		maxX = innerRectangle.innerWidth - rectangle.width;
		maxY = innerRectangle.innerHeight - rectangle.height;
		
		// 兼容 IE 6/7/8 拖拽 BUG
		Tool.setCaptureIE(_this);
		
		$(document).mousemove(function (eventObject) {
			// 捕获鼠标当前坐标
			mouseX = eventObject.clientX;
			mouseY = eventObject.clientY;
			
			// 获取元素位置
			var moveX = mouseX - fixedX;
			var moveY = mouseY - fixedY;
			
			if (moveX < minX) {
				moveX = minX;
			} else if (moveX > maxX) {
				moveX = maxX;
			}
			
			if (moveY < minY) {
				moveY = minY;
			} else if (moveY > maxY) {
				moveY = maxY;
			}
			
			$(_this).css(['left = ' + moveX + 'px', 'top = ' + moveY + 'px']);
		});
		$(document).mouseup(function () {
			// 兼容 IE 6/7/8 拖拽 BUG
			Tool.releaseCaptureIE(_this);
			$(document).mousemove(function () {
				return null;
			});
			return null;
		});
	});
	return this;
};

// drag 隶属方法: 获取元素外边距
Base.prototype.drag.getOuterRectangle = function (elementNode) {
	var _this = $(elementNode);
	var outerX = _this.css('left');
	var outerY = _this.css('top');
	var display = _this.css('display');
	
	if (display != 'none' || outerX == 'auto' || outerY == 'auto') {
		_this.show();
		outerX = elementNode.offsetLeft;
		outerY = elementNode.offsetTop;
	}
	
	outerX = _this.center.split(outerX, 'px');
	outerY = _this.center.split(outerY, 'px');
	
	return {
		outerX : outerX,
		outerY : outerY
	}
};

// 防止元素溢出
Base.prototype.overflow = function () {
	var innerRectangle = Tool.getInnerRectangle();
	var outerRectangle = {}, rectangle = {}, minX = 0, minY = 0, maxX = 0, maxY = 0;
	for (var i = 0; i < this.elements.length; i ++) {
		this.center.absolutePosition(this.elements[i]);
		outerRectangle = this.drag.getOuterRectangle(this.elements[i]);
		rectangle = this.center.getRectangle(this.elements[i]);
		maxX = innerRectangle.innerWidth - rectangle.width;
		maxY = innerRectangle.innerHeight - rectangle.height;
		
		if (outerRectangle.outerX < minX) {
			outerRectangle.outerX = minX;
		} else if (outerRectangle.outerX > maxX) {
			outerRectangle.outerX = maxX;
		}
		if (outerRectangle.outerY < minY) {
			outerRectangle.outerY = minY;
		} else if (outerRectangle.outerY > maxY) {
			outerRectangle.outerY = maxY;
		}
		
		$(this.elements[i]).css(['left = ' + outerRectangle.outerX + 'px', 'top = ' + outerRectangle.outerY + 'px']);
	}
	return this;
};

/*
	源码作者: 石不易(Louis Shi)
	联系方式: http://www.shibuyi.net
	===================================================================================================
	程序名称: JavaScript 工具库(跨浏览器兼容) BETA 1.0 版
	迭代版本: 无
	功能总数: 17 个
	功能介绍: 
		1. 实现获取计算样式
		2. 样式规则添加和移除
		3. 获取事件对象 event
		4. 取消事件默认行为与冒泡处理
		5. 现代事件绑定添加和移除
		...
*/
var Tool = {

	// 跨浏览器获取计算后的样式
	getStyle : function (elementNode, cssKey) {
		if (typeof window.getComputedStyle != 'undefined') { // W3C
			return window.getComputedStyle(elementNode, null)[cssKey];
		} else if (typeof elementNode.currentStyle != 'undefined') { // IE 6/7/8
			return elementNode.currentStyle[cssKey];
		}
	},
	
	// 跨浏览器添加 rule
	addRule : function (sheetObject, ruleName, ruleText, positionIndex) {
		if (typeof sheetObject.insertRule != 'undefined') { // W3C
			sheetObject.insertRule(ruleName + ' {' + ruleText + '}', positionIndex);
		} else if (typeof sheetObject.addRule != 'undefined') { // IE 6/7/8
			sheetObject.addRule(ruleName, ruleText, positionIndex);
		}
	},
	
	// 跨浏览器移除 rule
	removeRule : function (sheetObject, positionIndex) {
		if (typeof sheetObject.deleteRule != 'undefined') { // W3C
			sheetObject.deleteRule(positionIndex);
		} else if (typeof sheetObject.removeRule != 'undefined') { // IE 6/7/8
			sheetObject.removeRule(positionIndex);
		}
	},
	
	// 跨浏览器获取rule集合
	getRules : function (sheetObject) {
		if (typeof sheetObject.cssRules != 'undefined') { // W3C
			return sheetObject.cssRules;
		} else if (typeof sheetObject.rules != 'udnefined') { // IE 6/7/8
			return sheetObject.rules;
		}
	},
	
	// 数组排序
	sort : function () {
		return {
			minToMax : function (min, max) { // 正序: 从小到大排序
				if (min < max) {
					return -1;
				} else if (min > max) {
					return 1;
				} else {
					return 0;
				}
			},
			maxToMin : function (min, max) { // 倒序: 从大到小排序
				if (min < max) {
					return 1;
				} else if (min > max) {
					return -1;
				} else {
					return 0;
				}
			}
		}
	},
	
	// 跨浏览器获取 event 对象
	getEvent : function (eventObject) {
		if (typeof eventObject == 'object') return eventObject; // W3C
		return window.event; // IE 6/7/8
	},
	
	// 跨浏览器获取事件绑定所属元素引用
	getEventTarget : function (eventObject) {
		eventObject = this.getEvent(eventObject);
		if (typeof eventObject.target != 'undefined') { // W3C
			return eventObject.target;
		} else if (typeof eventObject.srcElement != 'undefined') { // IE 6/7/8
			return eventObject.srcElement;
		}
	},
	
	// 跨浏览器取消事件默认行为
	preventEventDefault : function (eventObject) {
		eventObject = this.getEvent(eventObject);
		if (typeof eventObject.cancelable != 'undefined' && typeof eventObject.preventDefault != 'undefined') { // W3C
			if (eventObject.cancelable) eventObject.preventDefault();
		} else { // IE 6/7/8
			eventObject.returnValue = false;
		}
	},
	
	// 跨浏览器取消事件冒泡
	cancelEventPropagation : function (eventObject) {
		eventObject = this.getEvent(eventObject);
		if (typeof eventObject.bubbles != 'undefined' && typeof eventObject.stopPropagation != 'undefined') { // W3C
			if (eventObject.bubbles) eventObject.stopPropagation();
		} else if (typeof eventObject.cancelBubble != 'undefined') { // IE 6/7/8
			eventObject.cancelBubble = true;
		}
	},
	
	// 事件名称容错处理
	checkEventName : function (eventName) {
		if (typeof eventName == 'string' && eventName.indexOf('on') == 0) eventName = eventName.substring(2, eventName.length);
		return eventName;
	},
	
	// 跨浏览器现代事件绑定: 注册事件
	loginEvent : function (elementNode, eventName, method) {
		eventName = this.checkEventName(eventName);
		if (typeof elementNode.addEventListener != 'undefined') { // W3C
			elementNode.addEventListener(eventName, method, false);
		} else if (typeof elementNode.attachEvent != 'undefined') { // IE 6/7/8
			elementNode.attachEvent('on' + eventName, method);
		}
	},
	
	// 款浏览器现代事件绑定: 注销事件
	logoutEvent : function (elementNode, eventName, method) {
		eventName = this.checkEventName(eventName);
		if (typeof elementNode.removeEventListener != 'undefined') { // W3C
			elementNode.removeEventListener(eventName, method, false);
		} else if (typeof elementNode.detachEvent != 'undefined') { // IE 6/7/8
			elementNode.detachEvent('on' + eventName, method);
		}
	},
	
	// 跨浏览器绑定鼠标滚轮事件
	mousewheelEvent : function (elementNode, method) {
		if (typeof elementNode.onmousewheel != 'undefined') { // 非 Firefox
			elementNode.onmousewheel = function (eventObject) {
				method.call(this, Tool.getEvent(eventObject));
			};
		} else { // Firefox
			this.loginEvent(elementNode, 'DOMMouseScroll', method);
		}
	},
	
	// 跨浏览器获取网页可视区长度
	getInnerRectangle : function () {
		var width = 0; height = 0;
		if (typeof window.innerWidth != 'undefined' && typeof window.innerHeight != 'undefined') { // W3C
			width = window.innerWidth;
			height = window.innerHeight;
		} else { // IE 6/7/8
			width = document.documentElement.clientWidth;
			height = document.documentElement.clientHeight;
		}
		return {
			innerWidth : width,
			innerHeight : height
		}
	},
	
	// 跨浏览器滚动条重置
	scrollInitialization : function () {
		document.documentElement.scrollTop = 0; // 非 Chrome / Safari
		document.documentElement.scrollLeft = 0; // 非 Chrome / Safari
		document.body.scrollTop = 0; // Chrome / Safari
		document.body.scrollLeft = 0; // Chrome / Safari
	},
	
	// IE 浏览器独占: 监听鼠标点击
	setCaptureIE : function (elementNode) {
		if (typeof elementNode.setCapture != 'undefined') {
			elementNode.setCapture();
		}
	},
	
	// IE 浏览器独占: 监听释放鼠标
	releaseCaptureIE : function (elementNode) {
		if (typeof elementNode.releaseCapture != 'undefined') {
			elementNode.releaseCapture();
		}
	}
};

关于 BETA 1.0 原型版核心源码与实例演示的获取请移动至官网下载！

 

感谢大家积极评测给予意见！

 

官网地址：http://www.shibuyi.net

CNBlogs 博客：http://www.cnblogs.com/shibuyi/

CSDN 博客：http://blog.csdn.net/louis_shi/

ITeye 博客：http://shibuyi.iteye.com/