/*******************************************************
 *                                                     *
 *******************************************************/
//一些異常
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(){
}
//$pack函數當參數個數為1的時侯返回該參數，否則返回一個參數表
var $pack = function(){
	if(arguments.length == 1)
		return arguments[0];
	else
		return Array.apply(null, arguments);
}
//抽象函數，定義接口時使用，如果被調用，則拋出異常
//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}; 
} 
//獲得頁面文檔的大小
window.pageRect = function() 
{     
	var w = (window.innerWidth) ? window.innerWidth : document.body.offsetWidth;     
	var h = (window.innerHeight) ? window.innerHeight : 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;
}
//Serializer 序列化原型
function Serializer(){}
Serializer.prototype.serialize = function(encoder)
{
	var ret = [];
	encoder = encoder || 
		function(s){
			s = s || '';
			return s.replace(/\'/g,"\\'").replace(/([:{},])/g,function(s){s=s.charCodeAt(0).toString(16); while(s.length<4) s="0"+s; return "\\u"+s});
		}
	
	for(var each in this)
	{
		var o = this[each]
		if(!(o instanceof Function))
		{
			if(o.serialize instanceof Function)
			{
				o = o.serialize(encoder);
				ret.push("'"+encoder(each)+"'" + ":" + o);
			}
			else
				ret.push("'"+encoder(each)+"'" + ":" + "'" + encoder(o) + "'");
		}
	}

	return "{" + ret.join() + "}";
}

//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});
}
//刪除數組中第一個等于o的元素，返回被刪除元素的位置
//如果刪除的元素不存在，返回-1
Array.prototype.remove = function(o){
	var idx = this.indexOf(o);
	if(idx != -1)
	{
		this.splice(idx,1);
	}
	return idx;
}

//獲得從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.__getByNS__ = function(s)
{
	var n = s.split(".");
	var o = this;
	try{
		for(var i = 0; i < n.length; i++)
		{
			var t = n[i];
			if(parseInt(t).toString() == t)
			{
				o = o[t - 0];
			}
			else
				o = o[t];
		}
		return o;