silverna-packs.js

《JavaScript王者归来》examples.rar

/*******************************************************
 *                                                     *
 *******************************************************/
//一些异常
function ImplementationException(msg){
	msg = msg || "接口未正确实现！";
	var _e = new Error(msg);
	_e.number = "0x101001";
	return _e;
}
function EnvironmentException(msg){
	msg = msg || "运行环境错误！";
	var _e = new Error(msg);
	_e.number = "0x101002";
	return _e;
}
function TypeNotFoundException(msg){
	msg = msg || "指定类型不存在或无法实例化！";
	var _e = new Error(msg);
	_e.number = "0x101004";
	return _e;
}
//空函数
var $void = function(){
}
//抽象函数，定义接口时使用，如果被调用，则抛出异常
//Silverna中所有未实现的接口也调用此函数
var $abstract = function(){
	throw new ImplementationException();
}
var Silverna = {
	version : "2.0.0.1.20070726",
	author : "akira",
	implementation : $abstract
}
//获得浏览器屏幕窗口的大小
window.clientRect = function() 
{     
	var w = (window.innerWidth) ? window.innerWidth : 
		(document.documentElement && document.documentElement.clientWidth) 
			? document.documentElement.clientWidth : document.body.offsetWidth;     
	var h = (window.innerHeight) ? window.innerHeight : 
		(document.documentElement && document.documentElement.clientHeight) 
			? document.documentElement.clientHeight : document.body.offsetHeight;     
	return {width:w,height:h}; 
} 
//判断是否是IE浏览器
function $isIE()
{
	return /msie/i.test(navigator.userAgent);
}
//判断是否是Firefox浏览器
function $isFF()
{
    return /firefox/i.test(navigator.userAgent);
}
//判断是否是IE7.0浏览器
function $isIE7()
{
	return /msie 7/i.test(navigator.userAgent);
}
//获得文档的head，如果有的话
function $head(){
	var heads = document.getElementsByTagName("head"); 
	return heads ? heads[0] : null;
}
//获得文档的body，如果有的话
function $body(){
	var bodys = document.getElementsByTagName("body");
	return bodys ? bodys[0] : null;
}
//获得Silverna核心脚本所在的script DOM对象
var $script = (function(){
	var scripts = document.getElementsByTagName("script");
	return scripts.length ? scripts[scripts.length - 1] : null;
})();
//获得Silverna核心脚本的运行路径
function $root()
{
	return $script.getAttribute("src").replace(/[^\/]+$/g,'');
}
//检测一个包或者对象是否存在，不存在则抛出异常
function $require(packs)
{
	try{
		var obj = eval(packs);
		if(obj == null) throw new Error();
		return obj;
	}
	catch(ex)
	{
		throw new EnvironmentException("包或对象" + packs + "加载失败，是否未包含必要的文件？");
	}
}
//用指定参数依次检测一组closure的执行结果，如果正常执行，则返回该执行结果，否则检测下一个
//最后一个参数可以是一个参数列表
function $try(){
	var _args = arguments[arguments.length - 1];
	var len = arguments.length - 1;
	if(_args instanceof Function){
		_args = [];
		len++;
	}
	
	for(var i = 0; i < len; i++)
	{
		try{
			return arguments[i].apply(this, _args);
		}
		catch(ex){
		}
	}
}

//Iterator 迭代器原型
function Iterator(){}
Iterator.prototype.next = $abstract;
Iterator.prototype.hasNext = $abstract;
Iterator.prototype.toArray = function(){
	var _set = [this.item()];
	while(this.hasNext())
	{
		_set.push(this.item());
		this.next();
	}
	return _set;
}

//Array 数组扩展
//any是一个集合迭代函数，它接受一个闭包作为参数
//当集合中的任何一个元素调用闭包的结果返回非false时，any()返回计算结果，否则返回false
Array.prototype.any = function(closure, _set){	
	_set = _set || false;

	if(typeof closure == 'undefined')
		closure = function(x){return x};
	if(typeof closure != 'function')
	{
		var c = closure;
		closure = function(x){return x == c}
	}
	
	var args = Array.apply(this, arguments).slice(2);

	for(var i = 0; i < this.length; i++)
	{
		var rval = closure.apply(this, [this[i]].concat(args).concat(i))
		if(rval || rval === 0)
		{
			if(_set && _set.put)
				_set.put(rval);
			else
				return rval;
		}
	}

	return _set;
}
//each是一个集合迭代函数，它接受一个闭包作为参数和一组可选的参数
//这个迭代函数依次将集合的每一个元素和可选参数用闭包进行计算，并将计算得的结果集返回
Array.prototype.each = function(closure){
    closure = closure || undefined;
	var _set = [];
	_set.put = _set.push;
	return this.any.apply(this, [closure, _set].concat(Array.apply(this, arguments).slice(1)));
}
//all是一个集合迭代函数，它接受一个闭包作为参数
//当且仅当集合中的每一个元素调用闭包的返回结果为true时，它才返回true
Array.prototype.all = function(closure){
	return this.each.apply(this, arguments).length == this.length;
}

//除去数组中的null、false元素
Array.prototype.trim = function(){
    return this.each();
}

//判断数组中是否包含某个元素
Array.prototype.contains = function(el){
	return this.any(function(x){return x == el});
}

//获得数组中值等于el的第一个索引，若不存在返回-1
Array.prototype.indexOf = function(el){
	return this.any(function(x, i){return el == x?i:-1});
}
//获得从start到end的子数组
Array.prototype.subarr = function(start, end){
	end = end || Math.Infinity;
	return this.each(function(x, i){return i >= start && i < end ? x : null});
}
//这是一个集合迭代函数，它接受一个list和一个闭包
//返回这个闭包对于集合和list元素的一组匹配
Array.prototype.map = function(list, closure){
	if (typeof list == 'function' && typeof closure != 'function')
	{
		var li = closure;
		closure = list;
		list = li;
	}
	closure = closure || Array;

	return this.each(function(x, i){return closure(x, list[i])});
};
Array.prototype.iterator = function(){
	
	var _it = new Iterator();
	var _cursor = 0;
	var _arr = this;

	_it.next = function(){
		_cursor++;
		return _it;
	}

	_it.item = function(){
		return _arr[_cursor];
	}

	_it.hasNext = function(){
		return _cursor < _arr.length - 1;
	}

	return _it;
}
// 除去左边空白
String.prototype.leftTrim = function()
{
	return this.replace(/^\s+/g,""); 
} 
// 除去右边空白
String.prototype.rightTrim = function()
{
	return this.replace(/\s+$/g,""); 
}
// 除去两边空白
String.prototype.trim = function()
{
	return this.replace(/(^\s+)|(\s+$)/g,""); 
}
// 得到字节长度
String.prototype.bytes = function()
{
	return this.replace(/[^\x00-\xff]/g,"--").length;
}
//根据字符串返回javascript日期类型对象,如果不是合法的日期字符串返回null
Date.parseDate = function(date)
{
	if (date == null)
	{
		return new Date();
	}
	if (date instanceof Date)
	{
		return date;
	}
	else
	{
		date = new Date(date.replace(/-/g,"/"));
	}
	if (isNaN(date.getTime()))
	{
		return null;
	}
	else
		return date;
}
//返回当前日期对象所在月份的天数
Date.prototype.getDaysOfMonth = function(date)
{
	return this.getLastDayOfMonth().getDate();
}
//获得当前月的第一天
Date.prototype.getFirstDayOfMonth = function()
{
	var year = this.getFullYear();
	var month = this.getMonth();

	return new Date(year,month,1);
}
//获得当前月的最后一天
Date.prototype.getLastDayOfMonth = function()
{
	var year = this.getFullYear();
	var month = this.getMonth();

	return new Date(year,month+1,0);
}
//获得下个月的第一天
Date.prototype.getFirstDayOfNextMonth = function()
{
	var year = this.getFullYear();
	var month = this.getMonth();

	return new Date(year,month+1,1);
}
//获得上个月的第一天
Date.prototype.getLastDayOfLastMonth = function()
{
	var year = this.getFullYear();
	var month = this.getMonth();

	return new Date(year,month-1,0);
}
//返回距离当前日期若干天之前/之后的日期
Date.prototype.getDateFrom = function(days)
{
	if (isNaN(this.getTime()))
		return new Date();
	else 
		return new Date(this.getTime() + 3600 * 24 * 1000 * days);
}
//格式化日期： var date = new Date(); var dateStr = date.toFormattedDateString("YYYY-MM-DD");
Date.prototype.toFormattedDateString = function(patternString)
{
	if(patternString == null)
	return this.toLocaleString();	 

	var ret = patternString;
	var year = this.getFullYear();
	var month = this.getMonth() + 1;
	var date = this.getDate();
	var hour = this.getHours();
	var minute = this.getMinutes();
	var second = this.getSeconds();

	month = month > 9 ? "" + month : "0" + month;
	date = date > 9 ? "" + date : "0" + date;

	ret = ret.replace(/YYYY/gi,year);
	ret = ret.replace(/MM/g,month);
	ret = ret.replace(/DD/gi,date);

	ret = ret.replace(/HH/gi,hour);
	ret = ret.replace(/mm/g,minute);
	ret = ret.replace(/ss/gi,second);

	return ret;
}
Date.prototype.datePart = function()
{
	return new Date(this.getFullYear(), this.getMonth(), this.getDate());
}
Date.now = function()
{
	return new Date();
}
Function.prototype.bind = function(owner)
{
	var $pointer = this;
	return function()
	{
		return $pointer.apply(owner, arguments);
	}
}
//这个函数有两个版本，一是它能够让一个对象在一定时间之后调用某个方法，例如：a.defer(b,100);
//另一个是能够让一个方法延迟一段时间被调用，例如a.defer(100);
//还有一个可选的参数是args，它表示调用的参数
Function.prototype.defer = function(delay, args){
	var $pointer = this;
	if(!(args instanceof Array))
		args = [args];
    window.setTimeout(function(){
		return $pointer.apply(this, args);
	}, delay);
}
Object.prototype.defer = function(method, delay, args){
	var $pointer = this;
	if(!(args instanceof Array))
		args = [args];
	if(typeof(method) == "string")
		method = $pointer[method];
	args = args || [];
    window.setTimeout(function(){
		return method.apply($pointer, args);
	}, delay);
}
Object.prototype.__extend__ = function(_typecall, evtArgs)
{
	evtArgs = evtArgs || [];
	_typecall.apply(this, evtArgs);
}
//用一个函数侦听某个provider的输出，以一定的时间间隔delay（毫秒）
//当provider返回true的时候，侦听继续下去
//当provider返回false的时候，侦听结束
Function.prototype.listen = function(provider, delay, args)
{
	var $pointer = this;
	if(!(args instanceof Array))
		args = [args];
	setTimeout(function(){
		if(provider.apply($pointer, args))
		{
			$pointer.apply(null, args);
			$pointer.listen(provider, delay, args);
		}
	},delay);
};
(function(){
	Object.prototype.__getter__ = function(propName, closure){
		this["get"+propName.slice(0,1).toUpperCase() + propName.slice(1)] = closure;
	}
	Object.prototype.__setter__ = function(propName, closure){
		this["set"+propName.slice(0,1).toUpperCase() + propName.slice(1)] = closure;
	}	
})();
//$函数，有几个用途：
//直接调用返回一个空的function(){}
//将包含有length属性的对象转换为一个ArrayList
//把实现了Iterator原型的对象转换为一个ArrayList
//传入字符串,转换以该字符串为ID的DOM对象，传入其它对象直接返回
//传入多个字符串或对象，字符串转换为已该字符串为ID的DOM对象，其他对象不变，返回列表
function $(){
	var _args = Array.apply([], arguments);
		
	if(_args.length == 0)
		return $void;

	if(_args.length == 1)
	{
		var obj = $id(_args[0]) || _args[0];
		if(obj.nodeType == 1) return obj;

		if(obj.toArray){
				return obj.toArray();
		}

		if(typeof(obj) != "string" && obj.length)
		{
			var _set = [];
			for(var i = 0; i < obj.length; i++)
				_set.push(obj[i]);
			return _set;
		}
		return obj;
	}

	return _args.each(function(obj){
		return $id(obj) || obj;
	});
}
function $id(id){
	return document.getElementById(id);
}

//declare Packs
//这里的声明非常重要，它为对象建立正确的名字空间，才能被with语句所支持
var core = {
	events : {
		EventManager:null
	},
	web : {
		widgets : 
			{
				adorners : {
					Adorner : null,
					ButtonAdorner : null,
					DragDropAdorner : null,
					DatePickerAdorner : null,
					MopCalendarAdorner : null,
					SliderAdorner : null,
					WindowAdorner : null,
					behaviors : {
						Behavior : null,
						ClickBehavior : null,
						DragBehavior : null,
						HoverBehavior : null,
						SelectBehavior : null
					}
				}, 
				Widget : null,
				ButtonWidget : null,
				DragDropWidget : null,
				DatePickerWidget : null,
				MopCalendarWidget : null,
				SliderWidget : null,
				WindowWidget : null
			},
		HTMLElement : null,
		CSSStyleSheet : null
	}
}

with(core.events)
{
	//原型：EventManager是一个重要的原型，它用来赋予对象自定义事件的能力
	//当对象类型的原型继承EventManager时，对象具有定义、分派和捕捉事件的能力
	//EventManager有四个重要的方法dispatchEvent、captureEvent、addEventListener和removeEventListener
	EventManager = function()
	{
		this.dispatchEvent = function(eventType, eventArgs)
		{
			eventArgs = eventArgs || {};
			var events = this["on"+eventType];
			var called = 0;

			if(events && typeof(events) == "function")
				events = [events];

			if(!eventArgs.type) eventArgs.type = eventType;
			//阻止默认动作的执行
			eventArgs.preventDefault = function()
			{
				eventArgs.defaultOp = null;
			}
			//阻止事件起泡
			eventArgs.stopPropagation = function()
			{
				eventArgs.cancelBubble = true;
			}
			var $pointer = this;
			if(events)
			{
				for(var i = 0; i < events.length; i++)
				{

					setTimeout(
						(function(i){
							var evt = events[i];
							var len = events.length;
							var capturer = events.capturer;
							var capturerName = events.capturerName;
							return	function(){
								called++;