String.prototype.stripTags        = fStripTags;       // 删除标签
String.prototype.escapeHTML       = fEscapeHTML;      // html编码
String.prototype.unescapeHTML     = fUnescapeHTML;    // html解码
String.prototype.encodeHTML		  = fEncodeHTML;	 //html编码	
String.prototype.decodeHTML		  = fDecodeHTML;    // html解码
String.prototype.toInt            = fToInt;           // 字符串转换城整型
String.prototype.usc_hdc          = fUsc_hdc;         // url＆html解码
String.prototype.trim             = fTrim;            // 删除字符串两边的空格
String.prototype.ltrim            = fLtrim;           // 删除左边的空格
String.prototype.rtrim            = fRtrim;           // 删除右边的空格
String.prototype.len              = fLen;             // 字符串的长度,可以检查中文
String.prototype.left             = fLeft;            // 截取左边数起第几个字符,截取后用...代替
String.prototype.isNumber         = fIsNumber;        // 字符串是否是数字
String.prototype.checkSpecialChar = fCheckSpecialChar;// 检查数否右特殊字符
String.prototype.upFirstChar	  = fUpFirstChar;	  // 大写第一个字符
String.prototype.lowFirstChar	  = fLowFirstChar;	  // 大写第一个字符
Date.prototype.dateAdd            = fDateAdd;         // 日期类型增加天数
Date.prototype.format             = fDateFormat;      // 格式化日期为yyyy-MM-dd hh:mm:ss

/**
 * 文本输入框函数集合
 * 
 * @class 文本输入框对象
 */
function Field()
{
  // TODO
}
Field.clear             = fClear;           // 清除内容
Field.activate          = fActivate;        // 激活对象

/**
 * 元素函数集合
 * 
 * @class 元素对象
 */
function El()
{
  // TODO
}
El.toggle               = fToggle;          // 显示或者隐藏节点
El.hide                 = fHide;            // 隐藏节点
El.show                 = fShow;            // 显示节点
El.remove               = fRemove;          // 删除节点
El.insertElement        = fInsertElement;   // 插入节点
El.nextSibling          = fNextSibling;     // 下一个节点
El.preSibling           = fPreSibling;      // 前一个节点
El.createElement        = fCreateElement;   // 建立节点
El.setAttr              = fSetAttr;         // 设置属性
El.setStyle             = fSetStyle;        // 设置style属性
El.addClass             = fAddClass;        // 添加class
El.removeClass          = fRemoveClass;     // 删除class
El.setClass				= fSetClass;		// 设置class
El.delClass             = fDelClass;        // 删除一个或多个class
El.getX                 = fGetX;            // 获取节点的x坐标
El.getY                 = fGetY;            // 获取节点的y坐标
El.position				= fPosition;		// 节点的位置坐标
El.getCookie			= fGetCookie;
El.setCookie			= fSetCookie;
El.setImageSize			= fSetImageSize;


/**
 * event函数集合
 * 
 * @class event对象
 */
function EV(){}
EV.getTarget		= fGetTarget;			// 获取target
EV.getEvent			= fGetEvent;			// 获取event
EV.getCharCode		= fGetCharCode;			// 获取charcode
EV.stopEvent		= fStopEvent;			// 取消事件和事件冒泡
EV.stopPropagation	= fStopPropagation;		// 取消事件冒泡
EV.preventDefault	= fPreventDefault;		// 取消事件
EV.pointerX			= fPointerX;			// 鼠标x位置
EV.pointerY			= fPointerY;			// 鼠标y位置
EV.observers		= false;				// 监听事件的缓存对象
EV.observeAndCache  = fObserveAndCache;		
EV.unloadCache		= fUnloadCache;			// 取消所有事件监听
EV.stopObserving	= fStopObserving;		// 取消事件监听
EV.observe			= fObserve;				// 增加事件监听
/**
 * 检查字符串是否是合法的email地址格式
 * 
 * @deprecated
 * @param  {string}str  Email地址
 * @return {String}     如果Email地址错误返回空字符串
 *
 * @see     #isEmailAddr
 */
function checkNoNamePart( str )
{
  str.toLowerCase();
  str.replace(/\s/gi, "");
  if (str.search("@") < 0)
  {
    return "";
  }
  return str;
}
/**
 * 将完整的email地址转换成xxx@xxx.xxx
 * 
 * @deprecated
 * @param  {string}strstrEmail  Email地址
 * @return {String}             返回xxx@xxx.xxx格式的Email地址
 */
function parseSingleEmail( sEmail )
{
  sEmail.replace(/\s/gi, "");
  var pos1 = sEmail.lastIndexOf("<");
  var pos2 = sEmail.lastIndexOf(">");
  if (pos1>=0 && pos2>=0 && pos2>pos1)
  {
    var NoNamePart = sEmail.substring(pos1, pos2);
    return checkNoNamePart(NoNamePart);
  }
  else
  {
    if (pos1>=0 || pos2>=0){
      return "";
    }else{
      return checkNoNamePart(sEmail);
    }
  }
  return "";
}
/**
 * 检查字符串是否是合法的格式
 *
 * @param  {string}strEmail  Email地址
 * @return {Boolean}         如果Email地址错误返回空字符串
 */
function isEmailAddr ( sEmail )
{
    return /\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*/.test(sEmail);
}
/**
 * 检查字符串是否是合法的手机号码
 *
 * @param  {string}sPhone  手机号码
 * @return {Boolean}       返回是否合法的手机号码
 */
function isPhoneNum ( sPhone )
{
   return /^13[\d]{9}$/.test(sPhone) || /^15[39][\d]{8}$/.test(sPhone);

}
/**
 * 截取字符串到第n位字符
 *
 * @param  {string}str 源字符串 
 * @param  {number}n   截取位置 
 * @return {String}    0-n的字符串
 */
function fFixStr(str , n){
  var i,j;
  var s="";
  var len = str.length;
  for(i=0,j=1 ; i<len ; i++,j++){
    if(str.charCodeAt(i)>255){
      j++;
    }
    if( j>n ){
      break;
    }
    s+=str.charAt(i);
  }
  return s;
}
/**
 * 删除字符串:&quot;
 *
 * @param  {string}src 源字符串 
 * @return {String}    删除&quot后的字符串
 */
function fReplaceQuot(src){ 
  var re;
  var s ="";
  re = /&quot;/g;
  s = src.replace(re, "");    // 用 "" 替换 "&quot;"。
  return s; 
}


/**
 * 检查字符串的日期格式是否正确
 *
 * @param  {date}sDate  要验证的日期 
 * @return {Boolean}    日期格式是否合法，合法的格式为yyyy-MM-dd 
 */
function fCheckDate(sDate){
  var arr = sDate.split("-");
  var d = new Date(arr[0],arr[1]-1,arr[2]);
  if(d.getFullYear() != arr[0] || (d.getMonth()+1) != parseInt(arr[1],10) || d.getDate() != parseInt(arr[2],10)){
    return false;
  }
  return true;
}

/**
 * 去掉字符串两边的空格
 *
 * @param   void   
 * @return {String} 去掉两边空格后的字符串    
 */
function fTrim(){
  return this.replace(/(^\s*)|(\s*$)/g, "");
}

/**
 * 去掉字符串左边的空格 
 *
 * @param   void   
 * @return {String} 去掉左边空格后的字符串    
 */
function fLtrim(){
  return this.replace(/(^\s*)/g, "");
}

/**
 * 去掉字符串右边的空格
 *
 * @param   void   
 * @return {String} 去掉右边空格后的字符串    
 */
function fRtrim(){
  return this.replace(/(\s*$)/g, "");
}

/**
 * 去掉字符串的所有空格
 *
 * @param   void   
 * @return {String} 去掉所有空格后的字符串    
 */
function fCleanBlank(){
  return this.replace( /\s/g, "");
}

/**
 * 检查字符串是否含有"% \' \" \\ \/ "的字符
 *
 * @param  {boolean}flag  是否检测特殊字符  
 * @return {Boolean}      如果有特殊字符返回false,否则返回true
 */
function fCheckSpecialChar(flag){
  var reg=/[,%\'\"\/\\;|]/;
  if( this.search( reg ) != -1)
  {
    if(flag){
      // CC.showSysMsg( "请不要输入 ＂, % \' \" \\ \/ ；|＂ 等特殊字符。");
    }
    return false;
  }
  return true;
}

/**
 * 大写首字符
 *
 * @param  void 
 * @return {String}      大写后的字符
 */
function fUpFirstChar(){
	if(this.length > 1){
		return this.substring(0,1).toUpperCase()+this.substr(1);
	}else{
		return this.toUpperCase();
	}
}

/**
 * 小写首字符
 *
 * @param  void 
 * @return {String}      大写后的字符
 */
function fLowFirstChar(){
	if(this.length > 1){
		return this.substring(0,1).toLowerCase()+this.substr(1);
	}else{
		return this.toLowerCase();
	}
}

/**
 * 取字符串长度,包括中文字的长度，一个中文字符长度为2
 *
 * @param   void  
 * @return {Number}  字符串的长度    
 */
function fLen(){
  var len=0;
  for (var i=0;i<this.length;i++){
    if (this.charCodeAt(i)>255){
      len+=2; 
    }else{
      len++;
    }
  }
  return len;
}

/**
 * 删除标签字符串
 *
 * @param   void
 * @return {String}   删除标签后的字符串 
 */
function fStripTags(){
    return this.replace(/<\/?[^>]+>/gi, '');
};

/**
 * html编码
 *
 * @param   void
 * @return {String}   编码后的html代码
 */
function fEscapeHTML(){
    var oDiv = document.createElement('div');
    var sText = document.createTextNode(this);
    oDiv.appendChild(sText);
    return oDiv.innerHTML;
};

/**
 * html解码
 *
 * @param   void
 * @return {String}  解码后的html代码  
 */
function fUnescapeHTML(){
    var oDiv = document.createElement('div');
    oDiv.innerHTML = this.stripTags();
    return oDiv.childNodes[0].nodeValue;
};
function fEncodeHTML(){
  var s = this;
  s = s.replace(/&/gi,"&amp;");
  s = s.replace(/</gi,"&lt;");
  s = s.replace(/>/gi,"&gt;");
  s = s.replace(/\"/gi,"&quot;");
  s = s.replace("\n","<br/>");
  return s;
}
/**
 * html解码
 */
function fDecodeHTML(){
	var s = this;
	s = s.replace(/&lt;/gi,"<");
	s = s.replace(/&gt;/gi,">");
	s = s.replace(/&quot;/gi,"\"");
	s = s.replace(/&amp;/gi,"&");
	s = s.replace(/&nbsp;/gi," ");
	return s;
}
/**
 * 字符串转整型
 *
 * @param   void  
 * @return {Number} 字符串对应的整数   
 */
function fToInt(){
  return parseInt(this,10);
};

/**
 * url＆html解码
 *
 * @param   void  
 * @return {String}  解码后的url＆html字符串  
 */
function fUsc_hdc(){
  return unescape(this.unescapeHTML());
};

/**
 * 截取字符串左边n位
 *
 * @param  {number}n  要截取的位数 
 * @return {String}   截取的字符串 
 */
function fLeft(len){
  var i = 0;
  var j = 0;
  if(this.len()<=len){
    return this;
  }
  while(j<len){
    if(this.charCodeAt(i)>255){
      j += 2;
    }else{
      j ++;
    }
    i ++;
  }
  return this.substring(0,i) + "..";
};

/**
 * 判断是否数字
 *
 * @param   void  
 * @return {Boolean}  返回是否数字   
 */
function fIsNumber(){
  return (this.search(/^\d+$/g) == 0);
}

/**
 * 日期变量增加n天
 *
 * @param  {number}n  要增加的天数,小于0表示减n天  
 * @return {Date}     增加了n天后的日期    
 */
function fDateAdd(n){
  return new Date(this.valueOf()+n*3600*24*1000);
};

/**
 * 格式化日期为 yyyy-MM-dd hh:mm:ss
 *
 * @param  {void}  
 * @return {String}
 *          返回字符串日期
 */
function fDateFormat()
{
    var ty = this.getFullYear();
    var tM = this.getMonth() + 1;
    var td = this.getDate();
    var th = this.getHours();
    var tm = this.getMinutes();
    var ts = this.getSeconds();
    // 格式化时间
    var sTime = ty + (tM<10 ? '-0' : '-')+ tM + (td<10 ? '-0' : '-')+ td + (th<10 ? ' 0' : ' ')+ th + (tm<10 ? ':0' : ":")+ tm + (ts<10 ? ':0' : ':')+ ts;
    // 返回时间
    return sTime
}

/**
 * 清除输入框的内容
 *
 * @param  {object}obj  输入框对象, 参数没有数量限制
 * @return {void}
 */
function fClear() {
  for (var i = 0; i < arguments.length; i++)
    $(arguments[i]).value = '';
}

/**
 * 激活对象
 *
 * @param  {object}element 需要激活的对象
 * @return {void}
 */
function fActivate(oElement) {
  try{
    $(oElement).focus();
    $(oElement).select();
  }catch(exp){}
}
/**
 * 通过id获取对象
 *
 * @param  {string}args  id字符串，可以有多个参数，用逗号分开
 * @return {Object}      根据id返回相应的对象   
 */
function $() {
  var aElements = new Array();
  for (var i = 0; i < arguments.length; i++) {
    var oElement = arguments[i];
    if(typeof oElement == 'string'){
		oElement = document.getElementById(oElement);
	}
	fExtendObj(El, oElement);
    if(arguments.length == 1){
		return oElement;
	}
    aElements.push(oElement);
  }
  return aElements;
}
/**
 * 继承对象属性
 * @param {object}org 源对象
 * @param {object}tag 目标对象
 * @return {void}
 */
function fExtendObj(oOrg, oTag){
	for(var o in oOrg){
		try{
			if(!oTag[o]){
				oTag[o] = oOrg[o];
			}
		}catch(exp){}
	}
}
/**
 * 获取对象
 * @private
 * @param  {object}param 如果param不是对象则将其作为对象id处理
 * @return {Object}      返回相应对象
 */
function fGetObj(sParam){
  var oElement = null;
  if(typeof(sParam) == 'object'){
    oElement = sParam;
  }else{
    oElement = $(sParam);
  }
  return oElement;
}

/**
 * 显示或隐藏对象,对象显示时就隐藏,隐藏时就显示
 *
 * @param  {string}args  对象或者对象id,参数没有数量限制
 * @return {void}
 */
function fToggle() {
	if(arguments.length == 0){
		this.style.display = (this.style.display == 'none' ? '' : 'none');
	}else{
		for (var i = 0; i < arguments.length; i++) {
			var oElement = fGetObj(arguments[i]);
			if(oElement){
			  oElement.style.display = (oElement.style.display == 'none' ? '' : 'none');
			}
		}
	}
}

/**
 * 隐藏对象
 *
 * @param  {string}args  对象或者对象id,参数没有数量限制
 * @return {void}
 */
function fHide() {
	if(arguments.length == 0){
		this.style.display = 'none';
	}else{
		for (var i = 0; i < arguments.length; i++) {
		  var oElement = fGetObj(arguments[i]);
		  oElement.style.display = 'none';
		}
	}
}

/**
 * 显示对象
 *
 * @param  {string}args  对象或者对象id,参数没有数量限制
 * @return {void}
 */
function fShow() {
	if(arguments.length == 0){
		this.style.display = '';
	}else{
		for (var i = 0; i < arguments.length; i++) {
		  var oElement = fGetObj(arguments[i]);
		  oElement.style.display = '';
		}
	}
}

/**
 * 删除对象
 *
 * @param  {string}args  对象或者对象id,参数没有数量限制
 * @return {void}
 */
function fRemove() {
	if(arguments.length == 0){
		this.parentNode.removeChild(this);
	}else{
		for (var i = 0; i < arguments.length; i++) {
			oElement = fGetObj(arguments[i]);
			oElement.parentNode.removeChild(oElement);
		}
	}
}

/**
 * 插入对象
 *
 * @param  {object}element 基准对象，要插入的对象在该对象的前后
 * @param  {object}obj     要插入的对象
 * @param  {string}place   要插入的位置:beforeBegin,afterBegin,beforeEnd,afterEnd
 * @return {void}
 */
function fInsertElement(oElement,obj,sPlace){
  try{
	if(arguments.length == 2){
		var sPlace = obj;
		var obj = oElement;
		var oElement = this;
	}
	var oParent = oElement.parentNode;
    var nLen = oParent.childNodes.length;
    var nPos = -1;
    for(var i=0;i<nLen;i++){
      if(oParent.childNodes[i] == oElement){
        nPos = i;
      }
    }
    if(sPlace == "beforeEnd"){
      oElement.appendChild(obj);
    }else if(sPlace == "afterEnd"){
      if(nPos == nLen-1){
        oParent.appendChild(obj);
      }else{
        oParent.insertBefore(obj,oParent.childNodes[nPos+1]);
      }
    }else if(sPlace == "beforeBegin"){
      //oElement.insertBefore(obj);
		oParent.insertBefore(obj,oParent.childNodes[nPos]);

    }else if(sPlace == "afterBegin"){
      if(oElement.childNodes.length == 0){
        oElement.appendChild(obj);
      }else{
        oElement.insertBefore(obj,oElement.childNodes[0]);
      }
    }
  }catch(exp){
    fDebug("fInsertElement",exp.description);
  } 
}

/**
 * 获取对象的下一个对象
 *
 * @param  {object}element 执行方法的对象
 * @return {Object}        element的下一个对象
 */
function fNextSibling(oElement){
  try{
	if(!oElement){
		oElement = this;
	}
    var oParent = oElement.parentNode;
    var aChilds = oParent.childNodes;
    for(var i=0;i<aChilds.length;i++){
      if(aChilds[i] == oElement){
        if(i == aChilds.length-1){
          return null;
        }else{
          return aChilds[i+1];
        }
      }
    }
  }catch(exp){
    fDebug("fNextSibling",exp.description);
  } 
}

/**
 * 获取对象的前一个对象
 *
 * @param  {object}element 执行方法的对象
 * @return {Object}        element的前一个对象
 */
function fPreSibling(oElement){
  try{
	if(!oElement){
		oElement = this;
	}
    var oParent = oElement.parentNode;
    var aChilds = oParent.childNodes;
    for(var i=0;i<aChilds.length;i++){
      if(aChilds[i] == oElement){
        if(i == 0){
          return null;
        }else{
          return aChilds[i-1];
        }
      }
    }
  }catch(exp){
    fDebug("fPreSibling",exp.description);
  } 
}

/**
 * 在indexFrame里建立对象
 *
 * @param {string}tag  要建立的对象的标签
 * @param {object}     返回根据标签建立的对象
 */
function fCreateElement(sTag, sId){
	if(sId){
		var o = $(sId);
		if(o){
			El.remove(o);
		}
	}
	var oElement = document.createElement(sTag);
	if(sId){
		oElement.id = sId;
	}
	fExtendObj(El, oElement);
	return oElement;
}

/**
 * 定义对象的属性
 *
 * @param {string}oElement 执行方法的对象
 * @param {object}oAttrObj 要设置属性的集合,格式:{'height':'100px','width':'200px'}
 * @param {void}
 */
function fSetAttr(oElement, oAttrObj){
	if(arguments.length == 1){
		var oAttrObj = oElement;
		var oElement = this;
	}
	for(var o in oAttrObj){
		oElement[o] = oAttrObj[o];
	}
}

/**
 * 定义style属性
 *
 * @param  {object}oElement  要操作的对象
 * @param  {string}oStyleObj 要设置style属性的集合,格式:{'height':'100px','width':'200px'}
 * @return {void}
 */
function fSetStyle(oElement, oStyleObj){
	if(arguments.length == 1){
		var oStyleObj = oElement;
		var oElement = this;
	}
	for(var o in oStyleObj){
		oElement.style[o] = oStyleObj[o];
	}
}

/**
 * 添加css的class
 *
 * @param  {object}element   执行方法的对象
 * @param  {string}sClassName 要添加的class名称
 * @return {void}
 */
function fAddClass(oElement, sClassName){
	if(arguments.length == 1){
		var sClassName = oElement;
		var oElement = this;
	}
    var sOldName = " "+oElement.className.trim()+" ";
    var sNewName = " "+sClassName+" ";
    if (sOldName.indexOf(sNewName)==-1){
	    oElement.className += " " + sClassName;
    }
}

/**
 * 删除对象的样式，包括一个或多个样式
 *
 * @param  {object}element     待删除样式的对象
 * @param  {string}className   需增加的样式
 * @return {void}         
 */
function fDelClass(oElement,sClassName)
{
	if(arguments.length == 1){
		var sClassName = oElement;
		var oElement = this;
	}
    oElement.className = oElement.className.replace(sClassName,"");
}

/**
 * 删除css的class
 *
 * @param  {object}element   执行方法的对象
 * @param  {string}sClassName 要删除的class名称
 * @return {void}
 */
function fRemoveClass(oElement, sClassName){
	if(arguments.length == 1){
		var sClassName = oElement;
		var oElement = this;
	}
	var aClass = oElement.className.split(" ");
	var arr = [];
	for(var i=0;i<aClass.length;i++){
		if(aClass[i] != sClassName){
		  arr[arr.length] = aClass[i];
		}
	}
	oElement.className = arr.join(" ");
}
/**
 * 设置class
 */
function fSetClass(oElement, sClassName){
	if(arguments.length == 1){
		var sClassName = oElement;
		var oElement = this;
	}
	oElement.className = sClassName;
}
/**
 * 取对象的x坐标
 *
 * @param  {object}element  执行方法的对象
 * @return {Number}         对象的x坐标
 */
function fGetX(oElement){
	if(!oElement){
		var oElement = this;
	}
	var l=oElement.offsetLeft;
	while(oElement=oElement.offsetParent){        
		l+=oElement.offsetLeft;
	}
	return l;
}

/**
 * 取对象的y坐标
 *
 * @param  {object}element  执行方法的对象
 * @return {Number}         对象的y坐标
 */
function fGetY(oElement){
	if(!oElement){
		var oElement = this;
	}
	var t=oElement.offsetTop;
	while(oElement=oElement.offsetParent){
		t+=oElement.offsetTop;
	}
	return t;
}

/****************************
		COOKIE操作函数
*****************************/
/**
*获得cookie对应字段的值
*var sName 需要获得的cookies关键字
*/
function fGetCookie(sName){
    var sRetValue;
    if (window.document.cookie ==""){
		 return "";
    }

    var sFirstChar, sLaseChar;
    var sCookieTemp = window.document.cookie;
    sFirstChar = sCookieTemp.indexOf(sName+"=");

	var bFlag = false;
    if (sFirstChar == 0){
		bFlag = true;
	}else{
		sFirstChar = sCookieTemp.indexOf("; "+sName+"=");
		if(sFirstChar != -1){
			bFlag = true;
		}
	}
    if(bFlag){
		  if(sFirstChar == 0){
			  sFirstChar += sName.length + 1;
		  }else{
			  sFirstChar += sName.length + 3;
		  }
		  sLaseChar = sCookieTemp.indexOf(";", sFirstChar);
		  if (sLaseChar == -1){
				sLaseChar = sCookieTemp.length;
		  }
		  sRetValue = sCookieTemp.substring(sFirstChar, sLaseChar);
		  return sRetValue;
    }
	else{
    	return "";
    }
}

/**
*设置cookie对应字段的值
*var sName 需要获得的cookies关键字
*var sValue 设置对应的值
*var sDomain cookie保存的域
*var sPath 路径
*var exDays 过期天数，0为关闭浏览器过期
*/
function fSetCookie(sName,sValue,sDomain,sPath,sDays){
	var oExDate = new Date();
	oExDate.setTime(oExDate.getTime() + sDays*24*60*60*1000);

	sName = sName +"="+sValue;
	sDomain = (typeof sDomain == "undefined" || sDomain == "") ? "" : ";domain="+sDomain;
	sPath = (typeof sPath == "undefined" || sPath == "") ? "" : ";path="+sPath;
	sDays = (typeof sDays == "undefined" || sDays == "" || sDays == 0)? "" : ";expires="+oExDate.toGMTString();
	window.document.cookie = sName+sDays+sPath+sDomain;
}

/*
从新设置图片大小
**/


function fSetImageSize(oImg,iWidth,iHeight,isFixChanged){
	var oTmp = new Image();
	oTmp.src = oImg.src;
	if(!isFixChanged && (oTmp.width>oImg.width || oTmp.height>oImg.height)){
		return;
	}
	if(iWidth == 0){
		var iW = oTmp.width;
	}else{
		var iW = iWidth;
	}
	if(iHeight == 0){
		var iH = oTmp.height;
	}else{
		var iH = iHeight;
	}

	var p = (oTmp.height-0) / (oTmp.width-0);//默认高宽比

	var h = iW * p;//按宽缩小后的高
	var w = iH / p;//按高缩小后的宽
	
	if(w > iW){//如果按照高来缩放，宽超出要求
		oImg.style.width = iW+"px";//宽就是默认的
		oImg.style.height = Math.round(h)+"px";//按照宽的要求来缩放
	}
	
	if(h > iH){//如果按照宽来缩放，高超出要求
		oImg.style.width = Math.round(w)+"px";//按照高的要求来缩放
		oImg.style.height = iH+"px";//高就是默认的
	}

}

// extend function for coremail 3.0
/**
 * Returns the width of the client (viewport).
 * @return {Int} The width of the viewable area of the page.
 */
function fGetClientWidth(){
	return (document.documentElement.offsetWidth || document.body.offsetWidth);
}
/**
 * Returns the height of the client (viewport).
 * @return {Int} The height of the viewable area of the page.
 */
function fGetClientHeight(){
	return (self.innerHeight || document.documentElement.clientHeight || document.body.clientHeight);
}

/**
 * Returns the event's target element
 * @param {Event} ev the event
 * @param {boolean} resolveTextNode when set to true the target's
 *                  parent will be returned if the target is a 
 *                  text node
 * @return {HTMLElement} the event's target
 */
function fGetTarget(ev, resolveTextNode){
	if(!ev) ev = this.getEvent();
	var t = ev.target || ev.srcElement;

	if (resolveTextNode && t && "#text" == t.nodeName) {
		return t.parentNode;
	} else {
		return t;
	}
}
/**
 * Returns the event, should not be necessary for user to call
 * @param {Event} the event parameter from the handler
 * @return {Event} the event 
 */
function fGetEvent (e) {
	var ev = e || window.event;

	if (!ev) {
		var c = this.getEvent.caller;
		while (c) {
			ev = c.arguments[0];
			if (ev && Event == ev.constructor) {
				break;
			}
			c = c.caller;
		}
	}

	return ev;
}
/**
 * Returns the charcode for an event
 * @param {Event} ev the event
 * @return {int} the event's charCode
 */
function fGetCharCode (ev) {
	if(!ev) ev = this.getEvent();
	return ev.charCode || (ev.type == "keypress") ? ev.keyCode : 0;
}
/**
 * Convenience method for stopPropagation + preventDefault
 * @param {Event} ev the event
 */
function fStopEvent(ev) {
	if(!ev) ev = this.getEvent();
	this.stopPropagation(ev);
	this.preventDefault(ev);
}

/**
 * Stops event propagation
 * @param {Event} ev the event
 */
function fStopPropagation(ev) {
	if(!ev) ev = this.getEvent();
	if (ev.stopPropagation) {
		ev.stopPropagation();
	} else {
		ev.cancelBubble = true;
	}
}

/**
 * Prevents the default behavior of the event
 * @param {Event} ev the event
 */
function fPreventDefault(ev) {
	if(!ev) ev = this.getEvent();
	if (ev.preventDefault) {
		ev.preventDefault();
	} else {
		ev.returnValue = false;
	}
}
/**
 * 事件触发鼠标x坐标
 */
function fPointerX(event) {
	if(!event) event = this.getEvent();
	var doc = document;
    return event.pageX || (event.clientX + (doc.documentElement.scrollLeft || doc.body.scrollLeft));
};
/**
 * 事件触发鼠标x坐标
 */
function fPointerY(event) {
	if(!event) event = this.getEvent();
	var doc = document;
    return event.pageY || (event.clientY + (doc.documentElement.scrollTop || doc.body.scrollTop));
};
/**
 * 对象坐标
 */
function fPosition(oElement) {
	if(!oElement){
		var oElement = this;
	}
    var valueT = 0, valueL = 0;
    do {
      valueT += oElement.offsetTop  || 0;
      valueL += oElement.offsetLeft || 0;
      oElement = oElement.offsetParent;
    } while (oElement);
    return [valueL, valueT];
};

/**
 * 增加事件监视并cache下来
 */
function fObserveAndCache(oElement, name, observer, useCapture) {
    if (!this.observers) this.observers = [];
    if (oElement.addEventListener) {
      this.observers.push([oElement, name, observer, useCapture]);
      oElement.addEventListener(name, observer, useCapture);
    } else if (oElement.attachEvent) {
      this.observers.push([oElement, name, observer, useCapture]);
      oElement.attachEvent('on' + name, observer);
    }
}
/**
 * 移除所有监视和cache
 */
function fUnloadCache() {
    if (!this.observers) return;
    for (var i = 0; i < this.observers.length; i++) {
      this.stopObserving(this.observers[i][0],this.observers[i][1],this.observers[i][2],this.observers[i][3]);
      this.observers[i][0] = null;
    }
    this.observers = false;
}
/**
 * 增加事件监视
 */
function fObserve(oElement, name, observer, useCapture) {
    useCapture = useCapture || false;
    
    if (name == 'keypress' && (navigator.appVersion.match(/Konqueror|Safari|KHTML/) || oElement.attachEvent)){
		name = 'keydown';
	}
    
    this.observeAndCache(oElement, name, observer, useCapture);
}
/**
 * 移除监视
 */
function fStopObserving(oElement, name, observer, useCapture) {
    useCapture = useCapture || false;
    
    if (name == 'keypress' && (navigator.appVersion.match(/Konqueror|Safari|KHTML/) || oElement.detachEvent)){
		name = 'keydown';
	}
    
    if (oElement.removeEventListener) {
      oElement.removeEventListener(name, observer, useCapture);
    } else if (oElement.detachEvent) {
      oElement.detachEvent('on' + name, observer);
    }
}
/**
 * 哈希表类,初始化对象可以传数组，集合，或者不传参数
 *
 * @class 哈希表类
 */
function Hashtable(){
	this._hash = new Object();
	this._type = "object";
	window.$continue = new Object();
	window.$break = new Object();
	/**  
	 * 添加对象
	 * @param {string}key 添加的属性或者数组的索引
	 * @param {string}value 添加的对象，可以是任何类型
	 * @return {bool} 成功返回true，失败返回false
	 */
	this.add = function(key,value){
		if(value && value.nodeType && value.nodeType == 1){		// 扩展节点属性
			value = $(value);
		}
		if(key && key.nodeType && key.nodeType == 1){		// 扩展节点属性
			key = $(key);
		}
		if(this._type == "object"){
			if(typeof(key)!="undefined"){
				if(this.contains(key)==false){
					this._hash[key]=typeof(value)=="undefined"?null:value;
					return true;
				} else {
					return false;
				}
			} else {
				return false;
			}
		}else{
			if(typeof(value) != "undefined" && typeof(key)!="undefined"){
				this._hash[key] = value;
				return true;
			}else if(typeof(key)!="undefined"){
				this._hash[this._hash.length] = key;
				return true;
			}else{
				return false;
			}
		}
	};
	/**
	 * 删除对象
	 * @param {string} 要删除的属性或者数组的索引
	 * @return {void}
	 */
	this.remove = function(key){
		delete this._hash[key];
	};
	/**
	 * 对象集合的个数
	 * @param {void}
	 * @return {int} 返回个数
	 */
	this.count = function(){
		if(this._type == "array"){
			return this._hash.length;
		}
		var i=0;
		for(var k in this._hash){
			i++;
		} 
		return i;
	};
	/**
	 * 获取对象
	 * @param {string}key 属性或者索引
	 * @return {string} 返回该对象
	 */
	this.items = function(key){
		return this._hash[key];
	};
	/**
	 * 是否有该key的对象
	 * @param {string}key 属性或者索引
	 * @return 有就返回true，否则返回false
	 */
	this.contains = function(key){
		return typeof(this._hash[key])!="undefined";
	};
	/**
	 * 清空集合
	 * @param {void}
	 * @return {void}
	 */
	this.clear = function(){
		for(var k in this._hash){
			delete this._hash[k];
		}
	};
	/**
	 * 遍历集合
	 * @param {object}func function变量
	 * @return {void}
	 */
	this.each = function(func){
		try{
			if(this._type == "object"){
				for(var k in this._hash){
					try{
						func(k, this._hash[k]);
					}catch(e){
						if (e != $continue) throw e;
					}
				}
			}else{
				for(var k=0;k<this._hash.length;k++){
					try{
						func(k, this._hash[k]);
					}catch(e){
						if (e != $continue) throw e;
					}
				}
			}
		}catch(e){
			 if (e != $break) throw e;
		}
	};
	if(arguments.length>0){
		var arg = arguments[0];
		if(typeof arg == "object"){
			if(fIsValidCollection(arg) || arg.ie5){
				this._type = "array";
				this._hash = new Array();
				for(var i=0;i<arg.length;i++){
					this.add(i, arg[i]);
				}
			}else{
				for(var o in arg){
					this.add(o, arg[o]);
				}
			}
		}
	}
}
/**
 * We want to be able to use getElementsByTagName as a collection
 * to attach a group of events to.  Unfortunately, different 
 * browsers return different types of collections.  This function
 * tests to determine if the object is array-like.  It will also 
 * fail if the object is an array, but is empty.
 * @param o the object to test
 * @return {boolean} true if the object is array-like and populated
 */
function fIsValidCollection(o) {
	return ( o && (o.length || o.length == 0)&&typeof o != "string" && !o.tagName  && !o.alert);

}

/**
 * 交换数组元素的位置，
 * @param  {number}iIndex    需要交换元素的索引
 * @param  {number}iFlag     前后位置：-1--和前面的对象交换，1--和后面的对象交换
 * @return {void}
 */
Array.prototype.exchange = function (iIndex,iFlag)
{
     if (Math.max(0,iIndex,iIndex+iFlag)<0 || Math.min(this.length-1,iIndex,iIndex+iFlag)>this.length-1){
         return;
     }
     // 交换位置
     var oData = this[iIndex];
     this[iIndex] = this[iIndex+iFlag];
     this[iIndex+iFlag] = oData;
};

/**
 * 去除数组中的空元素
 * @return {Array}
 */
Array.prototype.escapeNull = function ()
{
    var aRtn = [];
    for (var i=0,len=this.length;i<len;i++){
        if(this[i]){
           aRtn[aRtn.length] = this[i];
        }
    }
    return aRtn;
};

/**
 * 数组克隆
 * @return {Array}
 */
Array.prototype.clone = function ()
{
    var aRtn = [];
    for (var i=0;this[i] && (aRtn[i]=this[i]);i++);
    return aRtn;
};

/**
 * 去除匹配内容的数组元素
 * @param  {String}sCnt 
 *          匹配内容
 * @return {Array}
 */
Array.prototype.subtract = function (sCnt)
{
    var aRtn = [];
    for (var i=0;s=this[i];i++){
        if (s!=sCnt){aRtn[aRtn.length]=s;};
    }
    return aRtn;
};

/**
 * 过滤元素中的特殊字符
 * @param  {RegExp | String}reg
 *          要过滤的字符
 * @return {void}
 */
Array.prototype.filter = function(reg)
{
    for(var i=0;s=this[i];i++){
       this[i] = s.replace(reg,"");
    }
};

/**
 * ie5增加push方法
 */
if (!Array.prototype.push) {
  Array.prototype.ie5  = true;
  Array.prototype.push = function() {
    var startLength = this.length;
    for (var i = 0; i < arguments.length; i++)
      this[startLength + i] = arguments[i];
    return this.length;
  }
}
/*和fckeditor有冲突
Array.prototype.splice = function(n){
	var arr = new Array();
	for(var i=0;i<this.length;i++){
		if(i != n){
		  arr[arr.length] = this[i];
		}
	}
	return arr;
};
*/
/**
 * ie5增加shift方法
 */
if (!Array.prototype.shift) {
  Array.prototype.shift = function () {
    var returnValue = this[0];
    for (i = 1; i < this.length; i++) {
      this[i - 1] = this[i];
    }
    this.length--;
    return returnValue;
  }
}

/**
 * ie5增加pop方法
 */
if (!Array.prototype.pop) {
  Array.prototype.pop = function () {
	  lastElement = this[this.length-1];
	  this.length = Math.max(this.length-1,0);
	  return lastElement;
  }
}
function fGoto(){}