/************************/
/*  功能：核心功能     	*/
/*  version：v1.0    	*/
/*  create：2009-6-25  	*/
/*  update：2009-8-27	*/
/************************/


/*************/
/* 客户端信息 */
/*************/
var client = {
	/*
		获取客户端浏览器
	*/
	Browser: {
		IE: 			!!(window.attachEvent&&!window.opera),
		Firefox:		new RegExp("FireFox\/([^\s]+)", "i").test(navigator.userAgent),
		Mazilla: 		window.navigator.userAgent.indexOf("Gecko/") > -1,
		Netscape:  		new RegExp("Netscape([\d]*)\/([^\s]+)", "i").test(window.navigator.userAgent),
		Opera: 			!!window.opera&&new RegExp("Opera[\s|\/]([^\s]+)", "i").test(window.navigator.userAgent),
		Safari: 		new RegExp("Safari\/([^\s]+)", "i").test(navigator.userAgent),
		Camino:			window.navigator.userAgent.indexOf("Camino") > -1,
		WebKit: 		window.navigator.userAgent.indexOf("AppleWebKit/") > -1,
		Maxthon:		new RegExp("Maxthon\s([\d.]+)", "i").test(window.navigator.userAgent),
		NetCaptor:		new RegExp("NetCaptor\s([^\s|;]+)", "i").test(window.navigator.userAgent),
		Gecko:  		window.navigator.userAgent.indexOf("Gecko") > -1&&window.navigator.userAgent.indexOf("KHTML") === -1,
		OmniWeb:		new RegExp("Safari\/([^\s]+)", "i").test(window.navigator.userAgent),
		Lynx:			new RegExp("OmniWeb\/(v*)([^\s|;]+)", "i").test(window.navigator.userAgent),
		MobileSafari: 	new RegExp("Apple.*Mobile.*Safari", "i").test(window.navigator.userAgent)
	}
}

/***
 * 功能：类继承
 * 参数说明：object 子类，object 父类
 * 返回值：object 子类
*/
Object.extend = function(cls, superclass){
	try{
		if(validate.datatype.isUndefined(superclass.prototype) === false){
			superclass = new superclass();
			for(var property in superclass){
				if(validate.datatype.isUndefined(cls.prototype) === true){
					cls[property] = superclass[property];
				}else{
					cls.prototype[property] = superclass[property];
				}
			}
		}else{
			for(var property in superclass){
				cls[property] = superclass[property];
	  		}
		}
  		return cls;
	}catch(e){
	}
}


/***********/
/* 窗口对象 */
/***********/
Object.extend(window, {
	/***
	 * 功能：设为首页
	 * 参数说明：object 页面对象，string 设为首页的路径，string 书签标题
	 * 返回值：
	*/
	setHomePage: function(pageObj, url, title){
		try{
			if(validate.datatype.isUndefined(url) === true){
				url = this.location.href;
			}
			if(validate.datatype.isUndefined(title) === true){
				title = this.title;
			}
			if(validate.datatype.isObject(this.sidebar) === true&&validate.datatype.isFunction(this.sidebar.addPanel) === true){
				this.sidebar.addPanel(title, url, "desc");
			}else{
				pageObj.style.behavior = "url(#default#homepage)";
				pageObj.setHomePage(url);
			}
		}catch(e){
		}
	},

	/***
	 * 功能：加入收藏
	 * 参数说明：string 收藏路径，string 页面名称
	 * 返回值：
	*/
	addFavorite: function(url, title){
		try{
			if(validate.datatype.isUndefined(url) === true){
				url = this.location.href;
			}
			if(validate.datatype.isUndefined(title) === true){
				title = this.title;
			}
			if(validate.datatype.isObject(this.sidebar) === true&&validate.datatype.isFunction(this.sidebar.addPanel) === true){
				this.sidebar.addPanel(title, url, "");
			}else{
				this.external.AddFavorite(url, title);
			}
		}catch(e){
		}
	},

	/***
	 * 功能：重载页面
	 * 参数说明：object 页面对象
	 * 返回值：
	*/
	reload: function(pageObj){
		try{
			if(validate.datatype.isUndefined(pageObj) === true){
				pageObj = window;
			}
			pageObj.location.reload();
		}catch(e){
		}
	},

	/***
	 * 功能：关闭窗口
	 * 参数说明：
	 * 返回值：
	*/
	Close: function(){
		try{
			this.opener = null;
			this.close();
		}catch(e){
		}
	}
});


/*************/
/* 字符串对象 */
/*************/
Object.extend(String, {});
Object.extend(String.prototype, {
	/***
	 * 功能：获取字符串对象中是否含有指定子字符
	 * 参数说明：string 子字符
	 * 返回值：boolean True/False
	*/
	exists: function(pattern){
		try{
			if(this.indexOf(pattern) > -1){
				return true;
			}else{
				return false;
			}
		}catch(e){
		}
	},

	/***
	 * 功能：获取字符串是否是空白
	 * 参数说明：
	 * 返回值：boolean True/False
	*/
	blank: function(){
		try{
			var pattern = /^[\s\r\n]*$/;
			if(pattern.test(this) === true){
				return true;
			}else{
				return false;
			}
		}catch(e){
		}
	},

	/***
	 * 功能：获取指定数目的从字符串的左边算起的字符
	 * 参数说明：int 返回的字符数目
	 * 返回值：string 新字符串
	*/
	left: function(length){
		try{
			var str = this;
			if(validate.checkData.isNumeric(length) === true){
				length = Number.parseInt(length);
				str = str.substr(0, length);
			}
			return str;
		}catch(e){
			alert(e.message);
		}
	},

	/***
	 * 功能：获取指定数目的从字符串的右边算起的字符
	 * 参数说明：int 返回的字符数目
	 * 返回值：string 新字符串
	*/
	right: function(length){
		try{
			var str = this;
			if(validate.datatype.isNumeric(length) === true){
				length = Number.parseInt(length);
				str = str.substr(str.length-length, length);
			}
			return str;
		}catch(e){
		}
	},

	/***
	 * 功能：获取指定字符串的重复n次后的字符串
	 * 参数说明：int 重复次数
	 * 返回值：string 指定字符串的重复n次后的字符串
	*/
	repeat: function(times){
		try{
			var str = this;
			if(validate.checkData.isNumeric(times) === true){
				times = Number.parseInt(times);
				for(var i = 0; i < times-1; i++){
					str += this;
				}
			}
			return str;
		}catch(e){
		}
	},

	/***
	 * 功能：获取字符串字节数
	 * 参数说明：
	 * 返回值：int 字符串字节数
	*/
	byte: function(){
		try{
			var byte = 0;
			for(var b = 0; b < this.length; b++){
				byte = this.charCodeAt(b) <= 256?byte+1:byte+2;
			}
			return byte;
		}catch(e){
		}
	},

	/***
	 * 功能：根据标识符将字符串转换为数组
	 * 参数说明：string 标识符
	 * 返回值：array 数组
	*/
	toArray: function(mark){
		try{
			if(validate.datatype.isUndefined(mark) === true){
				mark = "";
			}
			var array = this.split(mark);
			return array;
		}catch(e){
		}
	},

	/***
	 * 功能：去掉左空格
	 * 参数说明：string 字符串
	 * 返回值：string 去掉左空格后的字符串
	*/
	ltrim: function(){
		try{
			var str = this.replace(/^\s*/g, "");
			return str;
		}catch(e){
		}
	},

	/***
	 * 功能：去掉右空格
	 * 参数说明：string 字符串
	 * 返回值：string 去掉右空格后的字符串
	*/
	rtrim: function(){
		try{
			var str = this.replace(/\s*$/g, "");
			return str;
		}catch(e){
		}
	},

	/***
	 * 功能：去掉两端空格
	 * 参数说明：string 字符串
	 * 返回值：string 去掉两端空格后的字符串
	*/
	trim: function(){
		try{
			str = this.ltrim().rtrim();
			return str;
		}catch(e){
		}
	},

	/***
	 * 功能：替换字符串
	 * 参数说明：string/array 被替换的字符，string/array 替换字符
	 * 返回值：string 新字符串
	*/
	Replace: function(searchStr, replaceStr){
		try{
			if(validate.datatype.isArray(searchStr) === false){
				searchStr = [searchStr];
			}
			if(validate.datatype.isArray(replaceStr) === false){
				replaceStr = [replaceStr];
			}
			var str = this;
			var sex;
			var re;
			for(var s = 0; s < searchStr.size(); s++){
				sex = searchStr[s] instanceof RegExp === true?searchStr[s]:new RegExp(searchStr[s], "g");
				re = validate.datatype.isUndefined(replaceStr[s]) === true?"":replaceStr[s];
				str = str.replace(sex, re);
			}
			return str;
		}catch(e){
			alert(e.message);
		}
	},

	/***
	 * 功能：对HTML进行编码
	 * 参数说明：
	 * 返回值：string 编码后的HTML
	*/
	escapeHTML: function(){
		try{
			var vars = new Array(/&/g, /</g, />/g, /&/g);
			var values = new Array("&amp;", "&lt;", "&gt;", "&amp;");
			var html = this.Replace(vars, values);
				html = html.Replace(/"/g, "&quot;");
			return html;
		}catch(e){
		}
	},

	/***
	 * 功能：删除脚本代码
	 * 参数说明：
	 * 返回值：string 新字符串
	*/
  	stripScripts: function(){
		try{
			var str = this.Replace(/<script[^>]*>([\S\s]*?)<\/script>/img, "");
			return str;
		}catch(e){
		}
	},

	/***
	 * 功能：对HTML进行解码
	 * 参数说明：
	 * 返回值：string 解码后的HTML
	*/
	unescapeHTML: function(){
		try{
			var vars = new Array(/&amp;/g, /&lt;/g, /&gt;/g, /&quot;/g);
			var values = new Array("&", "<", ">", "\"");
			var html = this.Replace(vars, values);
			return html;
		}catch(e){
		}
	},

	/***
	 * 功能：删除HTML标签
	 * 参数说明：array 允许的HTML标签
	 * 返回值：string 新字符串
	*/
	stripTags: function(allowTags){
		try{
			var str = this;
			if(validate.datatype.isUndefined(allowTags) === true){
				str = str.Replace(/<\/?[^<>]+>/gi, "");
			}else{
				if(validate.datatype.isArray(allowTags) === false){
					allowTags = [allowTags];
				}
				var pattern;
				for(var t = 0; t < allowTags.length; t++){
					pattern = "<\/?[^<>"+allowTags[t]+"]+>";
					str = str.Replace(new RegExp(pattern, "gi"), "");
				}
			}
			return str;
		}catch(e){
		}
	},

	/***
	 * 功能：将第一字母大写[如果字符串的第一个字符为字母]
	 * 参数说明：
	 * 返回值：string 新字符串
	*/
	ucfirst: function(){
		try{
			var first = this.left(1).toUpperCase();
			var str = first+this.substr(1);
			return str;
		}catch(e){
		}
	},

	/***
	 * 功能：判断字符串是否相等
	 * 参数说明：string 字符串
	 * 返回值：boolean True/False
	*/
	equal: function(str){
		try{
			if(this == str){
				return true;
			}else{
				return false;
			}
		}catch(e){
		}
	}
});


/***********/
/* 数学对象 */
/***********/
Object.extend(Number, {

	/***
	 * 功能：将一个任意对象转换为整型
	 * 参数说明：mix 任意对象
	 * 返回值：int 整型
	*/
	parseInt: function(object){
		try{
			var int;
			switch(true){
				case validate.datatype.isNull(object): case validate.datatype.isUndefined(object): case validate.checkData.isNull(object):
					int = 0;
					break;
				case validate.datatype.isNumeric(object): case  validate.checkData.isNumeric(object):
					int = parseInt(object);
					break;
				case validate.datatype.isString(object):
					int = parseInt(object) === NaN?1:parseInt(object);
					break;
				case validate.datatype.isObject(object): case validate.datatype.isFunction(object):
					int = 1;
					break;
				case validate.datatype.isBoolean(object):
					int = object === true?1:0;
					break;
				case Array.isArray(object):
					int = object.length > 0?1:0;
					break;
				default:
					int = 0;
					break;
			}
			return int;
		}catch(e){
			alert("parseInt: "+e.message);
		}
	},

	/***
	 * 功能：判断一个数字是否为奇数
	 * 参数说明：int 数字
	 * 返回值：boolean True/False
	*/
	even: function(number){
		try{
			if(validate.checkData.isNumeric(number, "int") === true&&number%2 === 0){
				return true;
			}else{
				return false;
			}
		}catch(e){
		}
	},

	/***
	 * 功能：判断一个数字是否为奇数
	 * 参数说明：int 数字
	 * 返回值：boolean True/False
	*/
	odd: function(number){
		try{
			if(validate.checkData.isNumeric(number, "int") === true&&number%2 === 1){
				return true;
			}else{
				return false;
			}
		}catch(e){
		}
	},

	/***
	 * 功能：返回一个数是否在另外两个数之间
	 * 参数说明：int/float 检测的数，int/float 参照数，int/float 参照数
	 * 返回值：boolean True/False
	*/
	isBetween: function(number, min, max){
		try{
			if(number >= Math.min(min, max)&&number <= Math.max(min, max)){
				return true;
			}else{
				return false;
			}
		}catch(e){
		}
	},

	/***
	 * 功能：返回一个数是否为百分数
	 * 参数说明：int/float 检测的数
	 * 返回值：boolean True/False
	*/
	isPercent: function(number){
		try{
			var pattern = /^(-)?\d+(.\d+)?%$/;
			if(pattern.test(number.toString()) === true){
				return true;
			}else{
				return false;
			}
		}catch(e){
		}
	}//,
});


/***********/
/* 数学对象 */
/***********/
Object.extend(Math, {
	/***
	 * 功能：产生随机数
	 * 参数说明：int 最小值，int 最大值
	 * 返回值：int 随机数
	*/
	rand: function(Min, Max){
		try{
			if(validate.checkData.isNumeric(Min, "int") === false){
				Min = 0;
			}
			if(validate.checkData.isNumeric(Max, "int") === false){
				Max = calendar.date.solar.getTime();
			}
			var temp = new Array();
				temp["min"] = this.min(Min, Max);
				temp["max"] = this.max(Min, Max);
				Min = temp["min"];
				Max = temp["max"];
			var rand = this.random()*(Max - Min)+Min;
			rand = this.round(rand);
			if(rand < Min){
				rand = Min;
			}else if(rand > Max){
				rand = Max;
			}
			return rand;
		}catch(e){
		}
	},

	/***
	 * 功能：将任意数值转换为正整数
	 * 参数说明：number 数字
	 * 返回值：int 正整数
	*/
	plus: function(number){
		try{
			number = Number.parseInt(number);
			number = this.abs(number);
			return number;
		}catch(e){
		}
	}
});


/**************/
/* cookie对象 */
/**************/
var Cookie = function(){
	/***
	 * 功能：写Cookie
	 * 参数说明：string cookie名，string cookie值，int/string cookie过期日期，string 访问目录，sting 域
	 * 返回值：
	*/
	this.set = function(name, value, expires, path, domain){
		try{
			if(validate.datatype.isUndefined(expires) === true){
				expires = 0;
			}else if(validate.checkData.isNumeric(expires) === true){
				expires = Number.parseInt(expires)*1000;
				expires = calendar.time.solar.getTime()+expires;
				calendar.time.solar.setTime(expires);
				expires = calendar.toUTCString();
			}
			if(validate.datatype.isUndefined(path) === true){
				path = "";
			}
			if(validate.datatype.isUndefined(domain) === true){
				domain = config.base.domain.replace(/[w]{3}/, "");
			}
			var secure = uri.getPort() === 334?true:false;
			document.cookie = name+"="+escape(value)+"; path=/"+path+"; domain="+domain+"; expires="+expires;//+"; secure="+secure;
		}catch(e){
			alert("set: "+e.message);
		}
	}

	/***
	 * 功能：获取指定Cookie的值
	 * 参数说明：string cookie名
	 * 返回值：string/array cookie值
	*/
	this.get = function(name){
		try{
			var value = "";
			var cookie;
			var cookies = document.cookie.toArray("; ");
			for(var c = 0; c < cookies.length; c++){
				cookie = cookies[c].toArray("=");
				if(validate.datatype.isUndefined(name) === true){
					value[cookie[0]] = unescape(cookie[1]);
				}else{
					if(cookie[0] == name){
						value = unescape(cookie[1]);
						break;
					}
				}
			}
			return value;
		}catch(e){
			alert("get: "+e.message);
		}
	}

	/***
	 * 功能：删除Cookie
	 * 参数说明：string/array cookie名
	 * 返回值：
	*/
	this.del = function(name){
		try{
			if(validate.datatype.isArray(name) === false){
				name = [name];
			}
			for(var c = 0; c < name.length; c++){
				this.set(name[c], "", 0);
			}
		}catch(e){
		}
	}
}