(function(){
    /***************************************************************************
     *
     * Copyright (c) 2008-2009 广州资源软件有限公司，All Rights Reserved.
     *
     * @author: gsyn77
     * @version: 1.60
     *
     * @history:
     *	2009-01-08 by gsyn77 v0.96	- webpart.toggle()中跨域加载界面串行化
     *	2009-01-19 by gsyn77 v1.0	-
     *		扩展Panel对象(PL)增加模拟窗体属性和事件的处理；拆分‘事件注册处理’.
     *	2009-02-12 by gsyn77 v1.10	- 将eval方法替换为new Function(functionBody)()
     *		Syntax: new Function ([arg1[, arg2[, ... argN]],] functionBody)
     *			Parameters
     *				arg1, arg2, ... argN - Names to be used by the function as formal argument names.
     *					Each must be a string that corresponds to a valid JavaScript identifier
     *					or a list of such strings separated with a comma;
     *					for example "x", "theValue", or "a,b".
     *				functionBody - A string containing the JavaScript statements comprising the
     *					function definition.
     *	2009-02-16 by gsyn77 v1.20	- 将‘列表’和‘对话窗口’UI界面合并在一个界面UI源文件中
     *	2009-02-18 by gsyn77 v1.21	-
     * 		1. 不再使用自动邀请
     * 		2. 主动邀请不做任何处理而只是反向提交一个用户状态TC命令字
     *  2009-02-21 by gsyn77 v1.22 - 使用统一stack方式缓存所有widget-window状态
     *  	（init、normal、min、max）下的窗体大小
     *  2009-02-25 by gsyn77 v1.23 - 加入“顶部”、“底部”特效支持
     *
     *  2009-02-26 by gsyn77 v1.30
     *  	- 合并上、下、左、右的特效功能
     *  	- 将一些通用的动态效果方法转移到X命名空间下
     *  	- 进入新页面并使用Ui[CMD_INIT_SHOW]初始化界面消息内容时，如果存在输入callback或者延迟的任务（如需显示历史对话消息），调用之
     *  	- 【规则】列表对话不清除对话历史（Normal/Max-ChatWindow）
     *  2009-03-02 by gsyn77 v1.40
     *  	- 将UI模板加载方式改为js，不使用原来的iframe+html，以解决傲游等浏览器的兼容性问题
     *  2009-03-03 BY gsyn77
     *  	- 试图解决Firefox Layout Engine不能动态缩放定位容器的问题，未能完全解决
     *  	- 试图使用toggleExpo()解决 Google、Safari浏览器兼容性问题，未能完全解决
     *	2009-03-04 BY gsyn77 v1.41
     *	- 增加留言提交提示，修改了一些Bug
     *	2009-03-09 BY gsyn77 v1.42
     *	- 通过加入安装标签参数_bfn(BugFixNo)来特别修正浏览器兼容性问题，例如：
     *		http://service.webeye.net.cn/trackers.js?1&_bfn=198.1
     * 2009-03-13 BY gsyn77 v1.43
     * - 取消2009-03-03的修正
     * - 保留v1.42的修正
     * - 将widget界面布局从div+float改为table
     * 通过测试的浏览器包括：
     * 	IE(6、7、8)、Firefox(2.0.20、3.0.7)、傲游(2.x)
     * 未通过测试的浏览器包括：
     * 	Safari(4 public beta) - table布局内容隐藏（overflow:hidden）时会导致“空位”出现
     * 	Google Chormium(2.x) - table布局内容隐藏（overflow:hidden）时会导致“空位”出现
     * 	傲游(1.6.5) - 莫名其妙的隐藏不见，有时根本不出现
     * - fixes #198: 低配置机器回显后台消息时会出现闪烁现象，其原因在于回显后台消息时多做了一次
     * 		bindKey()操作，导致浏览器dom上的事件注册；由于物理内存不足导致整个显示内容闪动——实
     * 		际上在进行Drag&Drop操作时已经体现了这一点。
     * 2009-03-16 BY gsyn77 v1.43.1
     * - 将动画Step从原来的15改为5
     * - 将Fade Step从原来的 10 改为 2
     * - widget-chat-max关闭时加上边框
     * - 修正“拖曳”Bug —— 当拖曳发生在滚动到底部时，mouse坐标计算应该采用clientY而不是绝对PageY
     * - 增加列表为空的处理 —— 转为使用chat-widget
     * - 由服务端控制是否进行动态UI演示 —— 目前只控制在首次进入网站页面时演示动态ui效果
     * 	 需要更新服务端应用程序扩展（*.dll）
     * - 在center（x轴中部、y轴中部）对齐的浮动定位也受init.xml配置中偏移量x、y的影响
     * - 修正D&D鼠标定位不准问题
     * 2009-03-18 BY gsyn77 v1.51
     * - 测试动画在不同浏览器中的兼容性，并提交兼容性报告
     * 		IE - 6、7、8
     * 		傲游 - 1.6.5.18、2.5.1.4751
     * 		腾讯TT浏览器
     * 		360安全浏览器 - 1.5.0.2
     * 		Firefox - 2.0.20、3.0.7
     * 		谷歌Chronmium - 2.0.156.1
     * 		Safari(for Windows) - 4.0 public beta(528.16)
     * - 测试界面、动画在不同W3C标准下的兼容性，并提交报告
     * 		无DTD声明
     * 		HTML 4.0、4.01
     * 		XHTML 1.0 (Traditional、Strict)
     * 2009-03-23 BY gsyn77 v1.51.1
     * - 每次提交GET请求时都发送document.referrer和document.title参数
     * 2009-03-27 BY gsyn77 v1.52
     * - 使用controller1.js作为弹出窗口处理主体Js脚本；
     * - 当弹出窗口时，suspend主页面（源页面）的Keep-Online；
     * 	 直到弹出窗口被关闭时再恢复（每隔2秒钟检查一次弹出窗口状态 —— closed属性等于true）；
     * - 当弹出窗口时，最小化列表ui界面
     * - 支持底部ui场景下的弹出窗口
     * 2009-03-31 by gsyn77 v1.52
     * - 弹出窗口使用‘消息提示框’，在页面正中间显示 - U.uimodel()
     * - 在后台发来消息时使用‘消息提示框’显示内容 - Ui[CMD_SHOW_MSG]、Ui[CMD_SHOW_XMS]
     * 2009-04-07 by gsyn77 v1.52.1
     * - 提交联系方式后使用alert()显示提示信息，以避免访客重复提交
     * 2009-04-08 BY gsyn77 v1.52.2
     * - BUGFIXES #221：在每次保持连接请求参数中直接使用document.location、document.referrer
     * - BUGFIXES：IE 的 execCommand('save') 方法如果不立即保存，则会导致与服务器之间的连接中断；让访客自己通过菜单保存文件内容
     * - RULE-CHANGE: 后台退出对话也显示‘对话历史’
     * 2009-04-10 BY gsyn77 v1.53
     * - BUGFIXES #221：加入简单的通信加固机制
     *   - 每秒钟检查上次提交时间和当前时间是否超过3秒，如果超过立即提交保持连接命令字（附加参数：guard=1） —— 此请求只保持连接不做其他任何处理
     *   - 接收到服务器保持连接命令字后立即检查是否该通信往返超过3秒，如果超过立即提交保持连接命令字
     * - BUGFIXES #217：IE7中如果内容超过一定长度，则上述element.scrollTop = element.scrollHeight不起作用
     *   特別针对IE7增加如下处理脚本：echo.scrollTop = echo.scrollHeight - echo.clientHeight;
     * 2009-04-11 by gsyn77 v1.53.1
     * - BUGFIXES #222：IE8（标准模式）、火狐下拖动后再最小化停留位置出现问题
     *   规定：只能上、下拖曳
     * 2009-04-15 by gsyn77 v1.53.2
     * - 使用W3C的style.position='fixed'属性替代原有容器定位方法，并向后兼容ie6-版本
     * - BUGFIXES：IE8后台界面设置中window.name检查不起作用的
     * v1.54
     * - “百度留言板”脚本调试完毕
     * 2009-04-16 by gsyn77 1.54
     * - refs #232 - 支持（Js脚本中的）『文字预知』功能
     * 2009-04-21 by gsyn77 1.54.1
     * - fixes #236 - 当初始对话框内容过多时，自动切换到最大化对话框
     * 2009-03-18 BY gsyn77 v1.60
     * - 拆分tracker-all-org.js为common、base、controller和语言(zh-cn、zh-tw、en等)
     *************************************************************************/
    
	
	/***************************************************************************
 * @overview 脚本内核
 * @author gsyn77
 * @version 1.60
 * @history
 * 	- v1.0 基本完成
 *  - v1.1 对B/S通信进行加固
 *  - v1.1.1 使用W3C的style.position='fixed'属性替代原有容器定位方法，并向后兼容ie6-版本
 **************************************************************************/
//(function()
//{
    /**********************STAGE 1: eXtensive********************************/
    // Map over xwsdn in case of overwrite
    var ESC = escape, UEC = unescape,
	EMPTY = '',
	STRING_CONNECTOR = '&',
	_X = window.X, X = Xsdn = window.Xsdn = window.X = {}, logs_ = [], 
	udf = 'undefined', usf = 'string', udp = 'wsdn_panel_', 
	udn = 'number', udb = 'boolean', ufn = 'function', udu = 'about:blank', 
	Tr = true, Fa = false,	
	/**
	 * 保持连接、对话获取、监控状态 时间间隔
	 */
	DEFAULT_KEEPONLINE_INTERVAL = 3000,
	DEFAULT_CHATMSG_INTERVAL = 2000,
	DEFAULT_GUARD_INTERVAL = 1000,
	/**
	 * 
	 */
	HTTP_METHOD_POST = "POST",
	HTTP_METHOD_GET = 'GET',
	/**
	 * 
	 */
 	UI_WM_FLY = 'fly', //
 	UI_WM_POP = 'pop', //
 	UI_WM_STATIC = 'static', //
 	UI_MODE_NORMAL = 'normal', //
 	UI_MODE_REQUEST = 'request', //
 	
 	UI_USE_FLASH ='0', // 是否使用 flash 邀请框 0: 不使用； 1 ： 使用
 	/**
 	 * 
 	 */
	 BROWSER_QUIRKS = 'quirks', //
	 BROWSER_IE = 'ie', //
	 BROWSER_IE6 = 'ie6', //
	 BROWSER_IE7 = 'ie7', //
	 BROWSER_IE8 = 'ie8', //
	 BROWSER_FIREFOX = 'ff', //
	 BROWSER_OPERA = 'opera', //
	 BROWSER_SAFARI = 'safari', //
	 BROWSER_CHROME = 'chrome', //
	/**
	 * 
	 */
	TAG_A = 'a', //
	TAG_ATTRIBUTE_HREF = 'href', //
	TAG_ATTRIBUTE_FLOAT = 'float', //
	TAG_ATTRIBUTE_BACKGROUND = 'background', //
	TAG_ATTRIBUTE_INNERHTML = 'innerHTML',
	TAG_ATTRIBUTE_STYLE = 'style',
	TAG_ATTRIBUTE_DISPLAY = 'display',
	TAG_ATTRIBUTE_LEFT = 'left',
	TAG_ATTRIBUTE_RIGHT = 'right',
	TAG_ATTRIBUTE_TOP = 'top',
	TAG_ATTRIBUTE_WIDTH = 'width',
	TAG_ATTRIBUTE_HEIGHT = 'height',
	TAG_ATTRIBUTE_BOTTOM = 'bottom',
	TAG_ATTRIBUTE_POSITION = 'position',
	TAG_ATTRIBUTE_ZINDEX = 'zIndex',
	TAG_ATTRIBUTE_BORDER = 'border',
	TAG_ATTRIBUTE_FILTER = 'filter',
	TAG_ATTRIBUTE_OPACITY = 'opacity',
	TAG_VALUE_JSVOID = 'javascript:void(0);', //
	/**
	 * 
	 */
	STYLE_VALUE_BLOCK = 'block', 
	STYLE_VALUE_NONE = 'none',
	STYLE_VALUE_ABSOLUTE = "absolute",
	STYLE_VALUE_AUTO = "auto",
 	STYLE_VALUE_VISIBLE = 'visible', //
 	STYLE_VALUE_POINTER = 'pointer', //
 	STYLE_NOBORDER = '0px', //
	STYLE_UNIT_PX = 'px',
	STYLE_OPACITY_TRANSPARENT = 'alpha(opacity=0)', // 透明css
	STYLE_OPACITY_PARAMED = 'alpha(opacity=%1)',
	/**
	 * 
	 */
	PROPERTY_ICON='icon',//add by 罗标新 2009-11-25 固定图标形
    PROPERTY_WM='wm', //add by 罗标新 2009-11-25 弹出窗口
    	
	PROPERTY_PRESENCE_FRONTIER = 'pA',
	PROPERTY_ROUNDTRIP_COUNTER = 'rtc',
	PROPERTY_LAST_TICKS = 'lastticks', // 保持连接最后一次提交时间timestamp
	PROPERTY_LAST_ACK = 'lastack', // 服务器端“接力”状态
	PROPERTY_GUARD = 'guard', //标志位，标识当前请求为guard动作
	PROPERTY_WSID = 'wsid',
	PROPERTY_SID = 'sid',
	PROPERTY_EID = 'eid',	
	PROPERTY_ADVERT ="_xsdn_ad", //add by 罗标新 2009-09-10 广告来源
	PROPERTY_EMPLOYEE_STATE = 'state',
	PROPERTY_EMPLOYEE_ADDONSERVICE = 'ado',
	PROPERTY_USER_STATE = 'us',
	PROPERTY_USER_STATE_LAST = 'lus',
	PROPERTY_RUNTIME_ENCODING = 'enc',
	PROPERTY_PREFERRED_LANGUAGE = 'lang',
	PROPERTY_PAGE_LOCATION = 'loc',
	PROPERTY_PAGE_REFERER = 'ref',
	PROPERTY_SERVICE_PORT_URL_ROOT = 'rt',
	PROPERTY_SERVICE_PORT_ACTIONBASE = 'ab',
	PROPERTY_SERVICE_PORT_ACTIONOPERATOR = 'as',
	PROPERTY_CHAT_REQUEST_TIME_LAST = 'lct',
	PROPERTY_USER_MSG_BUFFER = 'buf',
	PROPERTY_USER_MSG_CURRENT = 'msg',
	PROPERTY_UI_STYLE_CURRENT = 'style',
	PROPERTY_DOCUMNET_TITLE = 'documentTitle',
	PROPERTY_MESSAGE_SLOT = 'msg_slot', //用於臨時存儲後臺發來消息（用於在標題欄中閃爍顯示）
	PROPERTY_DOCUMENT_TITLE_BLINK_STATUS = 'blink_status',
	PROPERTY_WINDOW_FOCUS_TIMESTAMP = 'focus_stamp',
	/**
     * User-State:
     * #0	Tour(T)  					-	一般浏览状态
     * 		Tour(TW) 					-	浏览过程中接收到invitation
     * #1 	Tour-Communicate(TC)		-	请求对话
     * 		Tour-Call(TP)				-	打开电话拨叫面板
     * 		Tour-Cancel(TN)				-	取消对话请求
     * 		Tour-Refuse(TR) 			-	拒绝invitation
     * 		Tour-Request-Timeout（TT）	-	请求（对话、电话）并未接通并且超时
     * #2	Communicating(C) 			-	对话中
     * 		Communicate Xms(CX)			-	Xms对话中
     * #3	Comm-Interval(CI)			-	结束了对话状态，继续浏览，后面有可能继续对话
     */
	PROPERTY_VALUE_USERSTATE_T = 'T',
	PROPERTY_VALUE_USERSTATE_TW = 'TW',
	PROPERTY_VALUE_USERSTATE_TC = 'TC',
	PROPERTY_VALUE_USERSTATE_TN = 'TN',
	PROPERTY_VALUE_USERSTATE_TT = 'TT',
	PROPERTY_VALUE_USERSTATE_TR = 'TR',
	PROPERTY_VALUE_USERSTATE_TP = 'TP',
	PROPERTY_VALUE_USERSTATE_C = 'C',
	PROPERTY_VALUE_USERSTATE_CX = 'CX',
	PROPERTY_VALUE_USERSTATE_CI = 'CI',
	/**
	 * 
	 */
	SERVICE_PORT_PREFIXER = 'live.aspx?',
	SERVICE_CALL_PREFIXER = 'docall.aspx?',
	SERVICE_POP_CHAT_PREFIXER = 'livechat.aspx?',
	SERVICE_CALL_HREF ='aspx/PhoneVisitors/FreePhone.aspx?', //底部弹出拨打电话界面href
	// TODO: 部署时需要更改此项 - 动态服务地址如：http://192.168.1.223/live/
	SERVICE_PORT_URI = 'http://live.webeye.net.cn/v8x/', 
	/**
	 * 
	 */
	CMD_ENTER = 'enter',
	JS_MODE_CHOSEN = '_wsdn_x_debug_',
	/**
	 * 动态效果配置参数
	 * - 与 bootslide.js 中相对应
	 */
	TIMER_INTERVAL_SLIDER = 50, 
	TIMER_STEP_SLIDER = 8, 
	SLIDER_DIRECTION_HORIZONTAL = 'w',
	SLIDER_DIRECTION_VERTICAL = 'h',
	SLIDER_DIRECTION_ALL = 'a',
	/**
	 * 预定义内部方法
	 */
	FUNCTION_NAME_EXPANDO, 
	FUNCTION_NAME_FADE,
	rQ,fN,fE,pF,wNF,xhrp,uA,ihr,ver,
    	
	/**
     * 浏览器信息采集器
     */
    uA = navigator.userAgent.toLowerCase(),
	ihr = {
        'browser': {
            version: (uA.match(/.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/) || [])[1],
            safari: /webkit/.test(uA),
            opera: /opera/.test(uA),
            msie: /msie/.test(uA) && !/opera/.test(uA),
            mozilla: /mozilla/.test(uA) && !/(compatible|webkit)/.test(uA),
			firefox: /mozilla/.test(uA) && /gecko/.test(uA) && /firefox/.test(uA),
			maxthon: !/maxthon 2\.0/.test(uA)
        },
        'cookies': {
            'enabled': navigator.cookieEnabled
        },
        'page': {
            'refer': typeof(document.referrer) == udf ? EMPTY : document.referrer,
            'location': typeof(document.location.href) == udf ? EMPTY : document.location.href
        },
        'enc': document.defaultCharset || document.charset || document.characterSet,
        'lang': navigator.language || navigator.userLanguage || navigator.browserLanguage
    },//
    /**************************************#149************************************************
     * 2009-05-14 by gsyn77 - #149
     *
     * 【FSO内置变量】
     * 变量名：_wsdn_wsfc
     *
     * 【FSO命令】
     * '$uecp' - READ：读取所有FSO内容（逗号分隔的Key=Value）； WRITE：触发存储【FSO内置变量】的所有属性值；
     * '$uecs' - READ-ONLY：获取当前FSO实际存储大小；
     * '$uecc' - WRITE-ONLY：清空当前FSO所有内容；
     * '$bingo' - WRITE-ONLY：直接获取指定属性在FSO中的值，FlashObject將回調Wc.ac(k,v)傳遞k的值給v；
     * '$gotcha' - WRITE-ONLY：直接獲取FSO中所有屬性的值並作為Json返回；FlashObject將回調W.Fxro(json)以傳入json結果；
     *
     * 【FSO默认序列化条目】 条目名称中的'*'由实际客户站点Id替换
     * '_uncsid_*' - 访客Id
     * '_unclvt_*' - 访客上次访问时间
     * '_unccvt_*' - 访客本次访问时间
     * '_uncvct_*' - 访客访问人次
     *
     * 明文：广州资源
     * 密钥：LiveFx
     * 密文： 121,173,23,211,104,22,77,150,99,127,255,18,180,168,102,91
     * 密文(Hex)：79,ad,17,d3,68,16,4d,96,63,7f,ff,12,b4,a8,66,5b
     ******************************************************************************************/
    OBJECT_LIVEFX = '_wsdn_wsfc.', //
     OBJECT_LIVEFX_SID = PROPERTY_SID, //
     OBJECT_LIVEFX_LVT = '_lvt_', //
     OBJECT_LIVEFX_CVT = '_cvt_', //
     OBJECT_LIVEFX_VCT = '_vct_', //
     CMD_LIVEFX_SAVE = '$uecp', //
     CMD_LIVEFX_WRITE = '$toucha', //
     CMD_LIVEFX_READ = '$uecp', //
     CMD_LIVEFX_SIZE = '$uecs', //
     CMD_LIVEFX_CLEAR = '$uecc', //
     CMD_LIVEFX_SEARCH = '$bingo', //
     CMD_LIVEFX_SEARCHALL = '$gotcha', //
     CRYPTO_LIVEFX_KEY_SAVE = '79,ad,17,d3,68,16,4d,96,63,7f,ff,12,b4,a8,66,5b',//
     // #287 - 用于IE中延迟到window.onload时处理的函数队列
     TASKLIST_AFTER_DOMCONTENT_LOAD = [],
	/**
	 * 切换页面后需要延时处理的任务
	 */
	TASKLIST_BEFORE_CUSTOM_PROCEDURE = [];
    
    X.br = ihr['browser'];
    ver = parseInt(X.br.version.substring(0, 1));
    X.location = ihr['page']['location'];
    X.refer = ihr['page']['refer'];
    X.enc = ihr[PROPERTY_RUNTIME_ENCODING];
    X.lang = ihr[PROPERTY_PREFERRED_LANGUAGE];
    X.zh = ihr[PROPERTY_PREFERRED_LANGUAGE].indexOf('zh') > -1 ? Tr : Fa;
    X.CookieEnabled = ihr['cookies'].enabled;
	
    X.DEBUG = X.location.toLowerCase().indexOf(JS_MODE_CHOSEN) > -1 ? Tr : Fa;
	
		/**
	 * 判断网址中是否包含广告来源
	 */
	X.advert=function()
	{
		var wsdn_location=X.location.toLowerCase();
		if(wsdn_location.indexOf(PROPERTY_ADVERT)> -1)
		{			
			 var advert_index=wsdn_location.indexOf(PROPERTY_ADVERT);
			 var advert_arr=wsdn_location.substring(advert_index).split('&')[0].split('=');
			 if(advert_arr.length>=2)
			 {
			 	if(X.br.firefox)
			 	{
			 		return advert_arr[1];
			 	}
			 	else
			 	{
			    	return ESC(advert_arr[1]);	
			    }			    	 
			 }
		}
		return "";
	}
	
    X.LOG = function(msg)
    {
        if (!X.DEBUG) return;
        if (msg) 
        {
            if (msg.lineNumber) 
            {
                logs_.push(msg.lineNumber);
            }
            else if (msg.line) 
            {
                logs_.push(msg.line);
            }
            if (msg.name) 
            {
                logs_.push(msg.name);
            }
            if (msg.message) 
            {
                logs_.push(msg.message);
            }
            logs_.push(msg);
            logs_.push('  \r\n');
        }
    };
    /**
     * 输出日志信息
     */
    X.OUT = function()
    {
        return logs_.join(EMPTY);
    };
    /**
     * 修补url
     * @param {Object} s - 相对或绝对url
     * @param {Object} b - 用于修补的根路径
     */
    X.surl = function(s, b)
    {
        if (!b) 
        {
            b = "http://";
        }
        return s.toLowerCase().indexOf('http://') > -1 ? s : b + s;
    };
	/**
	 * 判断s中是否包含r
	 * @param {Object} s
	 * @param {Object} r
	 */
	X.contains = function(s,r)
	{
		return s.indexOf(r) > -1 ? Tr : Fa;
	}
    /**
     *
     */
    X.doc = function()
    {
        return window['document'];
    };
    /**
     *
     */
    X.$ = function()
    {
        var els = [], i = 0, el, a = arguments;
        for (; i < a.length; i++) 
        {
            el = a[i];
            if (typeof el == usf) el = X.doc().getElementById(el);
            if (a.length == 1) return el;
            els.push(el);
        }
        return els;
    };
    /**
     *
     */
    X.head = function()
    {
        var doc = X.doc();
        return doc.getElementsByTagName("head")[0] || doc.documentElement;
    };
    /**
     *
     */
    X.body = function()
    {
        var doc = X.doc();
        return doc.body || doc.getElementsByTagName("body")[0];
    };
    /**
     *
     */
    X.E = function()
    {
        return X.doc().createElement(arguments[0]);
    };
	/**
	 * 清除定时器
	 * @param {Object} handler
	 */
	X.atc = function(handler)
	{
		if (handler) 
		{
			window.clearTimeout(handler);
		}
	};
	/**
	 * 清除定时器
	 * @param {Object} handler
	 */
	X.rtc = function(handler)
	{
		if (handler) 
		{
			window.clearInterval(handler);
		}
	};
	
    /**
     * 定时一段时间后执行
     *
     * @argument fn - function reference
     * @argument delays - work after specified milisecond
     * @return handler - return window.setTimeout()
     */
    X.at = function(fn, delays)
    {
        return window.setTimeout(fn, delays);
    };
    /**
     * 每隔一段时间后执行
     *
     * @argument fn - function reference
     * @argument delays - work per specified milisecond
     * @return handler - return window.setTimeout()
     */
    X.rt = function(fn, delays)
    {
        return window.setInterval(fn, delays);
    };
    /**
     * 动态加载：xml、css、js、json
     * 2009-03-02 modified by gsyn77 v1.40 - 增加onload时的回调方法
     */
    rQ = function(url, type, charset, fn)
    {
        var xpt = null, head = X.head();
        if (url) 
        {
            switch (type)
            {
                case "script":
                {
                    xpt = X.E("script");
                    xpt.charset = charset;
                    xpt.type = "text/javascript";
                    xpt.src = url;
                    break;
                }
                case "css":
                {
                    xpt = X.E("link");
                    xpt.charset = charset;
                    xpt.rel = "stylesheet";
                    xpt.setAttribute("rel", "stylesheet");
                    xpt.type = "text/css";
                    xpt.href = url;
                    break;
                }
            }
            if (xpt && xpt != null) 
            {
				/**
				 * 2009-05-27 by gsyn77 - #260
				 * 注释掉onload函数中动态删除<script/>的部分代码以避免ie崩溃现象
				 */
                // CSS inclusion - IE fires both events, onload first, then
                // onreadystatechange. FF fires nothing.
                // JS inclusion - IE fires onreadystatechange. FF fires onload.
                // Both will execute the script before firing the event.
				
                xpt.onload = xpt.onreadystatechange = function()
                {
                
                    if (!xpt.readyState || xpt.readyState == "loaded" || xpt.readyState == "complete") 
                    {
                        try 
                        {
							if (X.isF(fn))
							{
								fn.apply(this);
							}
							/*
                            if (type != "css") 
                            {
                                head.removeChild(xpt);
                            }
                            */
                        } 
                        catch (e) 
                        {
                            X.LOG(e);
                        }
                    }
                };
                
                // Use insertBefore instead of appendChild to circumvent an IE6
                // bug. This arises when a base node is used (#2709).
                head.insertBefore(xpt, head.firstChild);
                //head.removeChild(xpt);
            }
        }
    };
	fE = window.fE = []; // iframe events
 	fN = 0; // iframe events counter
    /**
     * prepared iFrame constructor
     */
    pF = function(name, callback)
    {
        var body = X.body(), frame = null, fNn = fN++;
        frame = X.E(X.br.msie ? "<iframe name='" + name + "'></iframe>" : "iframe");
        
        frame.name = name;
        frame.id = name;
        try 
        {
            frame.setAttribute('title', fNn); // 用于删除window._frameEvents中的对应事件处理方法
        } 
        catch (e) 
        {
            X.LOG(e);
        }
        window.fE[fNn] = function()
        {
            if (!frame.readyState ||
            (X.br.msie && (frame.readyState == "loaded" || frame.readyState == "complete"))) 
            {
                try 
                {
                    if (frame.contentWindow.location == udu) 
                    {
                        // opera and safari will do an onload for about:blank first,
                        // we can ignore this first onload
                        return;
                    }
                } 
                catch (e) 
                {
                    X.LOG(e);
                }
                
                if (frame) 
                {
                    var evt_id = frame.getAttribute('title');
                    X.body().removeChild(frame);
                    frame = null;
                    window.fE[evt_id] = null;
                    try 
                    {
                        delete window.fE[evt_id];
                    } 
                    catch (e) 
                    {
                        X.LOG(e);
                    }
                }
                if (X.isF(callback)) 
                {
                    callback.call(this);
                }
            }
        };
        
        if (X.br.msie) 
        {
            frame.onreadystatechange = window.fE[fNn];
        }
        else 
        {
            frame.onload = window.fE[fNn];
        }
        // use insertBefore instead of appendchild to avoid IE7+ Bug:
        // HTML Parsing Error: Unable to modify the parent container element
        // before the child element is closed (KB927917)
        body.insertBefore(frame, body.firstChild);
        
        return frame;
    };
	/**
     * Inspired by Dojo windowname
     */
    wNF = function()
    {
        var _state = 0, _self = this;
        
        this.T = function(name, url, callback)
        {
            var body = X.body(), frame = null, fNn = fN++, start = "_start";
            frame = X.E(X.br.msie ? "<iframe name='" + name +
            "'></iframe>" : "iframe");
            
            frame.name = name + start;
            frame.id = name;
            try 
            {
                frame.setAttribute('title', fNn); // 用于删除window._frameEvents中的对应事件处理方法
            } 
            catch (e) 
            {
                X.LOG(e);
            }
            frame[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
            window.fE[fNn] = function()
            {
                if (!frame.readyState ||
                (X.br.msie && (frame.readyState == "loaded" || frame.readyState == "complete"))) 
                {
                
                    try 
                    {
                        if (frame.contentWindow.location == udu) 
                        {
                            // 
                            // opera and safari will do an onload for
                            // about:blank
                            // first, we can ignore this first onload
                            if (_state != 1) 
                            {
                                return;
                            }
                        }
                    } 
                    catch (e) 
                    {
                    }
                    
                    if (_state == 1) 
                    {
                        state = 2;
                        try 
                        {
                            // try ... catch to avoid IE7+ error: 对象不支持此属性                            						               
                            if (frame) 
                            {
                                var data = frame.contentWindow.name, evt_id = frame.getAttribute('title');
                                X.body().removeChild(frame);
                                frame = null;
                                window.fE[evt_id] = null;
                                try 
                                {
                                    delete window.fE[evt_id];
                                } 
                                catch (e) 
                                {
                                    X.LOG(e);
                                }
                            }
                            if (X.isF(callback)) 
                            {
                            
                                callback.call(this, data);
                            }
                        } 
                        catch (e) 
                        {
                            X.LOG(e);
                        }
                    }
                    if (!_state) 
                    {
                        _state = 1;
                        var sameDomainUrl = udu;
                        frame.contentWindow.location = sameDomainUrl;
                    }
                }
            };
            if (X.br.msie) 
            {
                frame.onreadystatechange = window.fE[fNn];
            }
            else 
            {
                frame.onload = window.fE[fNn];
            }
            // use insertBefore instead of appendchild to avoid IE7+ Bug:
            // HTML Parsing Error: Unable to modify the parent container element
            // before the child element is closed (KB927917)
            body.insertBefore(frame, body.firstChild);
            frame.src = url;
            
            return;
        };
    };
	/**
     * XMLHTTPRequest动作：child-windowed state 下使用 post、get
     */
    xhrp = {
        /**
         * 【页面内】使用form发送post请求
         */
        ps: function(url, data)
        {
            try 
            {
                var body, holder, target, tid = "wsdn_tmpframe" + X.ticks().toString();
                body = X.body();
                target = pF(tid); // iframe
                target[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
                holder = X.E("form"); // form
                holder.id = "wsdn_tmpform" + X.ticks().toString();
                holder[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
                body.insertBefore(holder, body.firstChild);
                
                holder.target = target.id;
                holder.action = url;
                if (data) 
                {
                    if (X.isVS(data)) 
                    {
                        if (data.indexOf(STRING_CONNECTOR) > -1) 
                        {
                            var ar = data.split(STRING_CONNECTOR), isize = ar.length;
                            for (var i = 0; i < isize; i++) 
                            {
                                var arri = ar[i].split('='), n = arri[0], v = arri[1], h = X.E("input");
                                h.type = "hidden";
                                h.id = n;
                                h.name = n;
                                h.value = v;
                                holder.insertBefore(h, holder.firstChild);
                            }
                        }
                        else if (data.indexOf('=') > -1) 
                        {
                            var arri = data.split('='), n = arri[0], v = arri[1], h = X.E("input");
                            h.type = "hidden";
                            h.id = n;
                            h.name = n;
                            h.value = v;
                            holder.insertBefore(h, holder.firstChild);
                        }
                    }
                    // 如果是对象，则将其所有属性作为post参数
                    if (X.isO(data)) 
                    {
                        for (var prop in data) 
                        {
							if (data.hasOwnProperty(prop)) 
							{
								var h = X.E("input");
								h.type = "hidden";
								h.id = prop;
								h.name = prop;
								h.value = data[prop];
								holder.insertBefore(h, holder.firstChild);
							}
                        }
                    }
                }
               if(document.body.clientWidth)
                {
                	//add by luobx 2010-01-11 判断是否是爬虫
                	if(document.body.clientWidth>0)
                	{
		                holder.method = HTTP_METHOD_POST;
		                holder.submit();
                	}              
                }
                body.removeChild(holder);
            } 
            catch (e) 
            {
                X.LOG(e);
            }
            
        },
        /**
         * 动态加载脚本或CSS
         * 2009-03-02 modified by gsyn77 v1.40 - 增加onload时的回调方法
         * 
         * @param {Object} type
         * @param {Object} url
         * @param {Object} urlbase
         */
        load: function(type, url, urlbase,fn)
        {
            if (!X.isVS(type)) 
            {
                return;
            }
            if (!X.isVS(urlbase)) 
            {
                urlbase = EMPTY;
            }
            if (url.indexOf(';') > -1) 
            {
                var ar = url.split(';'), i = 0, ss;
                for (; i < ar.length; i++) 
                {
                    ss = X.isVS(ar[i]) && ar[i].indexOf('http://') > -1 ? ar[i] : urlbase + ar[i];
                    if (X.isVS(ar[i]) && ss != urlbase) 
                    {
                        rQ(ss, type, ihr[PROPERTY_RUNTIME_ENCODING],fn);
                    }
                }
            }
            else 
            {
                rQ(url, type, ihr[PROPERTY_RUNTIME_ENCODING],fn);
            }
        },
        /**
         * 动态加载脚本
         * 2009-03-02 modified by gsyn77 v1.40 - 增加onload时的回调方法
         * 
         * @param {Object} url		- relative/absolute url or urls list splitted by ';'
         * @param {Object} urlbase	- optional base url
         */
        xript: function(url, urlbase, fn){
            xhrp.load('script', url, urlbase, fn);
        },
		/**
		 * 动态加载CSS
		 * @param {Object} url
		 * @param {Object} urlbase
		 */
        xss: function(url, urlbase){
            xhrp.load('css', url, urlbase);
        }
    };
	
	X.ff = X.br.firefox;
	X.maxthon = X.br.maxthon;
	X.maxthon2 = !X.br.maxthon;
    X.msie = X.br.msie;
    X.msie6 = X.msie && ver < 7;
	X.msie7 = X.msie && ver == 7;
    X.msie7plus = X.msie && ver >= 7;
	/**
	 * 判断是否ie8
	 * -  注意：在 Windows Internet Explorer 6 中引入的 compatMode 属性已不受支持，
	 * 	取而代之的是在 Windows Internet Explorer 8 中引入的 documentMode 属性。
	 * 	当前使用 compatMode 的应用程序仍然可以在 Windows Internet Explorer 8 中运行；
	 * 	但是，它们已更新为使用 documentMode。
	 */
    X.msie8 = X.msie ? (document.documentMode ? Tr : Fa) : Fa;
	/**
	 * 判断IE浏览器的兼容性模式
	 * - 默认IE浏览器采用quirks模式
	 */
	X.quirks = X.msie ? Tr : Fa;
	/**
	 * 用于重新定义ie中当前采用的浏览器兼容模式
	 */
	if (X.msie8)
	{
		if (document.documentMode >= 7)
		{
			X.msie7 = Tr;
			X.msie7plus = Tr;
		}
		if (document.compatMode && document.compatMode == 'CSS1Compat')
		{
			X.quirks = Fa;
		}
	}
	else if (X.msie)
	{
		/**
		 * BackCompat	W3C-Standards-compliant mode is not switched on.	
		 * CSS1Compat	W3C-Standards-compliant mode is switched on
		 */
		if (document.compatMode && document.compatMode == 'CSS1Compat')
		{
			X.quirks = Fa;
		}
		if (X.msie6)
		{
			try
			{
				/**
				 * 一个未公开的方法来让IE对背景图进行缓存：document.execCommand("BackgroundImageCache",false,true)
				 * 用这种方法甚至避免了api调用，貌似是直接缓存在IE内存中。IE6下设置背景图片是不会被真正cache住的，
				 * 就算服务器做了cache。
				 */
				document.execCommand("BackgroundImageCache", false, true);
			}catch(e)
			{
				X.LOG(e);
			}
		}
	}
	
	X._useFix = window.addEventListener || (X.msie7plus && !X.quirks) ? true : false;
	

    X.xpt = xhrp.xript;
    X.xss = xhrp.xss;
    X.post = xhrp.ps;
	/**
	 * 广州资源软件有限公司版权所有2001-2009
	 * Key: wsdn_js
	 */
    X['C'] = [117,21,55,10,8,214,127,89,186,9,82,30,167,199,8,91,245,35,77,236,188,87,13,200,109,205,44,176,168,91,166,213,123,158,102,73,33,61,187,209,179,121,236,198,166,211,6,241,137,54,186,179,184,220,98,44];
    
    
    /**
     * 根据string字符串中的%1～%9，格式化输出
     */
    X.format = function(s)
    {
        var args = arguments, pattern = new RegExp('%([1-' + args.length + '])', 'g');
        return String(s).replace(pattern, function(match, index)
        {
            return args[index];
        });
    };
    
    	/**
	 * 格式化文字闪烁效果
	 * @param {string} s : message
	 * @param {string} fs : formatString
	 */
	 X.formatWordFlashString = function(s,fs)
	 {
	 	 var formatStr="";	 	
 	 	 for(var i=0;i<s.length;i++)
 	 	 {
 	 	 	 formatStr = formatStr + X.format(fs,s.charAt(i));
 	 	 }
 	 	 return formatStr;	 	
	 };
	 
    /**
     * 清理恶意脚本、CSS
     */
    X.clean = function(t)
    {
        return X.isVS(t) ? X.trim(t).replace(/<script[^<]*<\/.*script>/gi, EMPTY).replace(/<style[^<]*<\/.*style>/gi, EMPTY).replace(/<link[^<]>/gi, EMPTY) : EMPTY;
    };
    /**
     * 清理所有html、脚本、自定义表情等
     */
    X.clear = function(t,r)
    {
		if(!X.isVS(r)) r = EMPTY;
        return X.isVS(t) ? X.trim(t).replace(/#IMG(\d+)FC#/gi, r).replace(/<script[^<]*<\/.*script>/gi, r).replace(/<[^>]*>/gi, r) : EMPTY;
    };
    /**
     * 去除字符串两端的空白字符
     */
    X.trim = function(t)
    {
        return (t || EMPTY).replace(/^\s+|\s+$/g, EMPTY);
    };
    /**
     * 截断指定长度并返回结果
     * @param {Object} s
     */
    X.TC = function(s, len)
    {
        return !X.isVS(s) ? EMPTY : s.substring(s, len);
    };
    
    /**
     * 返回当前时间的ticks值(milliseconds)
     */
    X.ticks = function()
    {
        return new Date().getTime();
    };
    /**
     * 返回当前browser本地时间的字符串
     */
    X.Time = function()
    {
        return new Date().toLocaleTimeString();
    };
	/**
	 * 返回当前browser本地时间的‘年’字符串
	 */
	X.Year = function()
	{
		return new Date().getFullYear().toString();
	}
    /**
     * 返回当前browser本地日期的字符串
     */
    X.Date = function()
    {
        return new Date().toLocaleDateString();
    };
    /**
     * check sdo is valid object or not
     * @param {Object} sdo
     * @since 2009-07-26 by gsyn77 - 修改判断顺序；0也算valid
     */
    X.isO = function(sdo)
    {
        if (typeof sdo == udf || sdo == null) 
        {
            return Fa;
        }
		
        if (sdo || sdo == 0) 
        {
            return Tr;
        }
		return false;
    };
    /**
     * 检查s是否是字符串
     * @param {Object} s
     */
    X.isS = function(s)
    {
        return s && typeof s == usf ? Tr : Fa;
    };
    /**
     * 检查是否非空字符串
     * @param {Object} safari
     */
    X.isVS = function(s)
    {
        return (s && typeof s == usf && X.trim(s).length > 0) ? Tr : Fa;
    };
    /**
     * 检查是否是空字符串
     * 例外：非字符串、undefined、null都被算作“空字符串”
     * @param {Object} s
     */
    X.isES = function(s)
    {
        return (s && typeof s == usf) ? ((X.trim(s).length == 0) ? Tr : Fa) : Tr;
    };
    /**
     * 检查an是否为Array的实例
     * @param {Object} an
     */
    X.isA = function(an)
    {
        return (an && an.constructor == Array) ? Tr : Fa;
    };
    /**
     * 检查fn是否为一个Function实例
     * @param {Object} fn
     */
    X.isF = function(fn)
    {
        return (fn && fn.constructor == Function) ? Tr : Fa;
    };
    /**
     * 检查是否是电话号码
     * @param {Object} s
     */
    X.isPhone = function(s)
    {
        return /^(([0\+]\d{2,3}-)?(0\d{2,3})-)?(\d{7,13})(-(\d{3,}))?$/.test(s);
    };
    /**
     * 判断是否为合法数字
     * @param {Object} s
     */
    X.isNum = function(s)
    {
        return /(\d)+/.test(s);
    };
    /**
     * 检查是否是email
     * @param {Object} s
     */
    X.isEmail = function(s)
    {
        //return /^([a-zA-Z0-9._-])+@([a-zA-Z0-9_-])+(\.[a-zA-Z0-9_-])+/.test(s);
        return /^[-0-9.a-z_]+@([0-9a-z][-0-9.a-z_]+\.)+[a-z0-9]{2,4}$/i.test(s);
    };
    /**
     * 判断是否是中文（多字节语言）
     * @param {Object} s
     */
    X.isZH = function(s)
    {
        return (/%u.+/gi.test(s) || /%u.+/gi.test(ESC(s)) || s.indexOf('%u') > -1 || ESC(s).indexOf('%u') > -1) ? Tr : Fa;
    };
    /**
     * 检查浏览器是否支持flash(至少8.0)
     */
    X.FlashEnabled = function()
    {
        // 所需 Flash 的主版本号
        var requiredMajorVersion = 8;
        // 所需 Flash 的次版本号
        var requiredMinorVersion = 0;
        // 所需 Flash 的版本号
        var requiredRevision = 0;
        // 受支持的 Javascript 版本
        var jsVersion = 1.0;
        
        // 检测客户端浏览器类型
        var isIE = (navigator.appVersion.toLowerCase().indexOf("msie") != -1) ? true : false;
        var isWin = (navigator.appVersion.toLowerCase().indexOf("win") != -1) ? true : false;
        var isOpera = (navigator.userAgent.toLowerCase().indexOf("opera") != -1) ? true : false;
        jsVersion = 1.1;
        
        var plugin = (navigator.mimeTypes && navigator.mimeTypes["application/x-shockwave-flash"]) ? navigator.mimeTypes["application/x-shockwave-flash"].enabledPlugin : 0;
        if (plugin) 
        {
            var words = navigator.plugins["Shockwave Flash"].description.split(" ");
            for (var i = 0; i < words.length; ++i) 
            {
                if (isNaN(parseInt(words[i]))) continue;
				if (words[i] >= requiredMajorVersion)
				{
					return true;
				}
            }
        }
        else if (isIE && isWin) 
        {
            try 
            {
				//modify by 罗标新 改为 new Function(new ActiveXObject),不然ie 会报错
                var swfControl =new Function("new ActiveXObject('ShockwareFlash.ShockwareFlash."  + requiredMajorVersion.toString() + "');") ;
                if (X.isO(swfControl)) 
                {
                    return true;
                }
            } 
            catch (e) 
            {
                X.LOG(e);
            }
        }
        return false;
        /*
         // 检测 Flash Player 插件版本信息需要有 JavaScript 帮助器
         function JSGetSwfVer(i)
         {
         // NS/Opera 版本 >= 3 在插件数组中检查 Flash 插件
         if (navigator.plugins != null && navigator.plugins.length > 0)
         {
         if (navigator.plugins["Shockwave Flash 2.0"] || navigator.plugins["Shockwave Flash"])
         {
         var swVer2 = navigator.plugins["Shockwave Flash 2.0"] ? " 2.0" : "";
         var flashDescription = navigator.plugins["Shockwave Flash" + swVer2].description;
         descArray = flashDescription.split(" ");
         tempArrayMajor = descArray[2].split(".");
         versionMajor = tempArrayMajor[0];
         versionMinor = tempArrayMajor[1];
         if (descArray[3] != "")
         {
         tempArrayMinor = descArray[3].split("r");
         }
         else
         {
         tempArrayMinor = descArray[4].split("r");
         }
         versionRevision = tempArrayMinor[1] > 0 ? tempArrayMinor[1] : 0;
         flashVer = versionMajor + "." + versionMinor + "." + versionRevision;
         }
         else
         {
         flashVer = -1;
         }
         }
         // MSN/WebTV 2.6 支持 Flash 4
         else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.6") != -1) flashVer = 4;
         // WebTV 2.5 支持 Flash 3
         else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.5") != -1) flashVer = 3;
         // 较早的 WebTV 支持 Flash 2
         else if (navigator.userAgent.toLowerCase().indexOf("webtv") != -1) flashVer = 2;
         // 在所有其它情况下都无法检测
         else
         {
         
         flashVer = -1;
         }
         return flashVer;
         }
         // 如果不带参数调用，此函数会返回一个浮点值，它应该是 Flash Player 的版本或 0.0
         // 例如:Flash Player 7r14 返回 7.14
         // 当该版本或更高版本可用时，用 reqMajorVer、reqMinorVer、reqRevision 调用 If 函数后，函数将返回 true
         function DetectFlashVer(reqMajorVer, reqMinorVer, reqRevision)
         {
         reqVer = parseFloat(reqMajorVer + "." + reqRevision);
         // 循环向后在版本中寻找，直到找到最新版本
         for (i = 25; i > 0; i--)
         {
         versionStr = JSGetSwfVer(i);
         if (versionStr == -1)
         {
         return false;
         }
         else if (versionStr != 0)
         {
         versionArray = versionStr.split(".");
         versionMajor = versionArray[0];
         versionMinor = versionArray[1];
         versionRevision = versionArray[2];
         
         versionString = versionMajor + "." + versionRevision; // 7.0r24 == 7.24
         versionNum = parseFloat(versionString);
         // 主修订版本 >= 所请求的主修订版本，而且次修订版本 >= 所请求的次修订版本
         if ((versionMajor > reqMajorVer) && (versionNum >= reqVer))
         {
         return true;
         }
         else
         {
         return ((versionNum >= reqVer && versionMinor >= reqMinorVer) ? true : false);
         }
         }
         }
         return (reqVer ? false : 0.0);
         }
         var hasRightVersion = DetectFlashVer(requiredMajorVersion, requiredMinorVersion, requiredRevision);
         return hasRightVersion;
         */
    };
    /**
     * 弹出窗口控制器
     * @param {Object} url -  	一个可选的字符串，声明了要在新窗口中显示的文档的 URL。如果省略了这个参数，或者它的值是空字符串，那么新窗口就不会显示任何文档。
     * @param {Object} name - 一个可选的字符串，该字符串是一个由逗号分隔的特征列表，其中包括数字、字母和下划线，该字符声明了新窗口的名称。这个名称可以用作标记 <a> 和 <form> 的属性 target 的值。如果该参数指定了一个已经存在的窗口，那么 open() 方法就不再创建一个新窗口，而只是返回对指定窗口的引用。在这种情况下，features 将被忽略。
     * @param {Object} feature - 一个可选的字符串，声明了新窗口要显示的标准浏览器的特征。如果省略该参数，新窗口将具有所有标准特征。在窗口特征这个表格中，我们对该字符串的格式进行了详细的说明。
     * @param {Object} replace - 一个可选的布尔值。规定了装载到窗口的 URL 是在窗口的浏览历史中创建一个新条目，还是替换浏览历史中的当前条目。支持下面的值：
     * 		true - URL 替换浏览历史中的当前条目;
     * 		false - URL 在浏览历史中创建新的条目.
     * @param {Function} callback - 弹出窗口被阻止时的处理方法
     */
    X.popW = function(url, name, feature, replace, callback)
    {
        if (!X.isVS(url)) 
        {
            return; // url不是字符串
        }
        if (!X.isVS(name)) 
        {
            name = "_blank";
        }
        if (!X.isVS(feature)) 
        {
            feature = EMPTY;
        }
        if (typeof replace == udf) 
        {
            replace = Tr;
        }
		try {
			var win = window.open(url, name, feature, replace);
			if (!win) {
				if (X.isF(callback)) {
					callback.apply(this);
				}
				return Fa;
			}
			return win;
		}catch(e)
		{
			X.LOG(e);
			return Fa;
		}
    };
	/**
	 * 
	 * @param {Object} url
	 * @param {Object} wname
	 * @param {Object} top
	 * @param {Object} left
	 * @param {Object} width
	 * @param {Object} height
	 */
    X.newWin = function(url, wname, top, left, width, height)
    {   
        return X.popW(url, wname, feature = ['left=' + left,'top=' + top,'width=' + width,'height=' + height,'toolbar=yes','scrollbars=yes','resizable=no','location=no','status=no','menubar=yes','titlebar=no','directories=no','channelmode=no','fullscreen=no'].join(','));
    };
	/**
	 * 修正动画容器的位置 - 目前只支持横向、纵向
	 * @param {Object} elem
	 * @param {Object} dr
	 */
	function fixSliderPosition(elem,dr){
		var eo = elem, 
		di = dr == SLIDER_DIRECTION_HORIZONTAL ? 'left' : 'top',
		doc = X.doc().body,
		px;
		
		if (X.quirks)
		{
			doc = doc.parentNode;
		}
		if (dr == SLIDER_DIRECTION_HORIZONTAL)
		{
			px = doc.clientWidth + doc.scrollLeft - eo.offsetWidth;
		}
		else 
		{
			px = doc.clientHeight + doc.scrollTop - eo.offsetHeight;
		}
		if (X.isVS(eo))
		{
			eo = X.$(eo);
		}
		eo = wP.fpp(eo, udp); // find Parent Polygon
		if (eo && px)
		{
			eo['style'][di] = px.toString() + STYLE_UNIT_PX;
		}
	}
	/**
     * 动态效果 - 缩放边界
     * @param {Object} el
     * @param {Object} W
     * @param {Object} H
     * @param {Object} rW
     * @param {Object} rH
     * @param {Object} callback
     */
    FUNCTION_NAME_EXPANDO = function(el, W, H, rW, rH, callback)
    {
        var w = W - rW, h = H - rH, expW = X.rt(function()
        {
            if ((rW >= W && w > 0) || (rW <= W && w < 0)) 
            {
                var expH = X.rt(function()
                {
                    if ((rH >= H && h > 0) || (rH <= H && h < 0)) 
                    {
                        if (X.isF(callback)) 
                        {
                            callback.apply(this);
                        }
                        el[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT] = H + STYLE_UNIT_PX;
                        X.rtc(expH);
                        return;
                    }
                    rH += Math.floor(h / 10);
                    el[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT] = (rH).toString() + STYLE_UNIT_PX;
                }, 50);
                el[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = W + STYLE_UNIT_PX;
                X.rtc(expW);
                return;
            }
            rW += Math.floor(w / 10);
            el[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = (rW).toString() + STYLE_UNIT_PX;
        }, 50);
    };
    /**
     * 动态效果 - 淡入、淡出
     * @param {Object} io - fade in(-1) or out(1)
     * @param {Object} el - element to fade in or out
     * @param {Object} callback - call after fade action
     */
    FUNCTION_NAME_FADE = function(io, el, callback)
    {
        var max = 1, min = 0, step = io == -1 ? 10 : 1, fadeH = X.rt(function()
        {
            step = (step + io);
            var opa = step / 2 == max ? min : step / 2;
            // 如果完成‘淡入、淡出’效果
            if (opa == min) 
            {
                if (X.msie) 
                {
                    el[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_FILTER] = STYLE_OPACITY_PARAMED.replace('%1', max * 100);
                }
                else 
                {
                    el[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_OPACITY] = max;
                }
                
                if (callback) 
                {
                    callback.apply(this);
                }
                X.rtc(fadeH); // 清除计时器
                return;
            }
            if (X.msie) 
            {
                el[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_FILTER] = STYLE_OPACITY_PARAMED.replace('%1', opa * 100);
            }
            else 
            {
                el[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_OPACITY] = opa;
            }
        }, 100);
    };
    /**
     * 动态效果 - 滑动伸缩
     * @param {Object} io
     * @param {Object} elem
     * @param {Object} w
     * @param {Object} h
     * @param {Object} di
     * @param {Object} dr
     * @param {Object} fn
     */
    FUNCTION_NAME_SLIDER = function(io, elem, w, h, di, dr, fn)
    {
        if (!X.isO(elem)) 
        {
            X.LOG('elem is null');
            return;
        }
        function InFactor(step, d)
        {
            if (!d) 
            {
                d = TIMER_STEP_SLIDER;
            }
            return step / d; //Math.pow(step / d, 2);
        }
        
        di = di ? di : SLIDER_DIRECTION_HORIZONTAL; // 滑动方向控制：w、h、a，默认 - w
        dr = dr ? dr : TIMER_STEP_SLIDER; // 控制slide duration
        fn = X.isF(fn) ? fn : null; // 用于在Slide动作结束时触发的function
        /*
         * FIXME
         *	- 如果 w、h 等于 'auto'，则使用其实际scrollWidth、scrollHeight，
         *		但是目前scrollWidth、scrollHeight并非W3C标准属性
         */
        w = w == STYLE_VALUE_AUTO ? elem.scrollWidth : w;
        h = h == STYLE_VALUE_AUTO ? elem.scrollHeight : h;
        
        var interval, wMove, hMove, cMove, 
		wStep = 0, hStep = 0, cStep = 0, cSpan = 0, 
		wSpan = io * w, hSpan = io * h, 
		wBase = io < 0 ? w : 0, hBase = io < 0 ? h : 0, 
		cdi = di == SLIDER_DIRECTION_HORIZONTAL; // 判断slide方向 - true, horizontal; false, vertical
        /**
         *
         */
        function slide()
        {
            wMove = Math.floor(wSpan * InFactor(wStep++, dr));
            hMove = Math.floor(hSpan * InFactor(hStep++, dr));
            cMove = cdi ? wMove : hMove;
            cSpan = cdi ? wSpan : hSpan;
            cStep = cdi ? wStep : hStep;
            
            if (cMove != cSpan) 
            {			
                elem[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = cdi ? wBase + cMove + STYLE_UNIT_PX : w + STYLE_UNIT_PX;
                elem[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT] = !cdi ? hBase + cMove + STYLE_UNIT_PX : h + STYLE_UNIT_PX;				
            }
            else 
            {
                if (io < 0) 
                {
                    elem[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = '0' + STYLE_UNIT_PX;
                    elem[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT] = '0' + STYLE_UNIT_PX;
                }
                else 
                {
                    elem[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = w + STYLE_UNIT_PX;
                    elem[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT] = h + STYLE_UNIT_PX;
                }
            }
            
            if (cStep > dr) 
            {
                if (fn) 
                {
                    X.at(function(){fn.apply(this)},0);
                }
                X.rtc(interval);
            }

        }
        interval = X.rt(slide, TIMER_INTERVAL_SLIDER);
    };
    /**
     * 动态效果判定方法
     * @param {Object} elem
     * @return {Number} - 1, to be expanding; -1, to be collapsing
     */
    FUNCTION_NAME_SLIDE_INOUT = function(elem)
    {
        if (X.isVS(elem)) 
        {
            elem = X.$(elem);
        }
        if (elem && elem[TAG_ATTRIBUTE_STYLE] && parseInt(elem[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH]) == 0) 
        {
            return 1;
        }
        return -1;
    };
    /**
     * 动态效果 - 缩放边界
     */
    X.exdo = FUNCTION_NAME_EXPANDO;
    /**
     * 动态效果 - 淡入、淡出
     */
    X.exfa = FUNCTION_NAME_FADE;    
    /**
     * 动态效果 - 滑动伸缩
     */
    X.exsl = FUNCTION_NAME_SLIDER;
    /**
     * 动态效果判定方法
     */
    X.exio = FUNCTION_NAME_SLIDE_INOUT;
    /**
     * 限定dragO在浏览器ClientArea内
     * @param {Object} dragO
     * @param {Object} top - mouse event.clientY
     * @param {Object} left
     * @param {Object} relativeAxis - 标识top、left是否是相对坐标
     */
    function SurroundClientArea(dragO, top, left, relativeAxis)
    {
        var CA = ClientArea(), 
		CW = CA.w, 
		CH = CA.h, 
		cW = (dragO.offsetWidth || dragO.clientWidth), 
		cH = (dragO.offsetHeight || dragO.clientHeight),
		doc = X.body(), cTop = document.documentElement.scrollTop || doc.scrollTop,
		relativeY;
        /**
         * 修正：不能拖曳出浏览器ClientArea边界
         */
        if (left < 0) 
        {
            left = 0;
        }
        if (left + cW >= CW) 
        {
            left = CW - cW;
        }        
        
        if (top < 0) 
        {
           relativeY = top = 0;
        }
        else 
        {        
			if (X._useFix) // style.position = 'fixed' 使用的是相对坐标
			{
				if (top > CH - cH) 
				{
					top = relativeY = CH - cH;
				}				
			}
			else 
			{
				if (top - cTop > CH - cH) 
				{
					top = CH + cTop - cH;
					relativeY = CH - cH;
				}
			}
        }
        
        return {
            x: left,
            y: top,
			ry: relativeY
        };
    }
    /**
     * 获得浏览器ClientArea的大小
     */
    function ClientArea(){
        var doc = document.documentElement || X.doc(), body = X.body(), //
        bCW = doc.clientWidth || body.offsetWidth || body.clientWidth, //
        bCH = doc.clientHeight || body.clientHeight || body.offsetHeight;
        
        /*
         * BUGFIX 2009-06-23 by gsyn77 - 解决在非标准XHTML场景下非IE浏览器定位高度不正确的问题 
         * Firefox 3.0.11
         * 1. 沒有聲明<!DocType...>時document.doctype = null
         * 2. 可以使用document.compatMode == 'BackCompat'
         */
        if (!X.msie && (document.doctype == null 
		|| (document.compatMode && document.compatMode.toLowerCase() == 'backcompat') 
		|| (document.documentElement 
        && document.documentElement.clientHeight > document.body.clientHeight) )) {
			bCH = document.body.clientHeight;
        }
		
        return {
            w: bCW,
            h: bCH
        };
    }
    /*************************END OF DEFINITION OF X***************************/
    
    /*************STAGE 2: Initializing Wsdn namespaces***************************/
    
    if (window.W) 
    {
        var _W = window.W;
    }
    var W = Wsdn = window.Wsdn = window.W = {}, Wc = W.core = window.Wc = {}, // 内核
	 Wi = W.ui = window.Wi = {}, // ui 
	 U = W.user = window.U = {}, // 用户
	 Ui = W.user.ui = window.Ui = {}, // 用户 ui
	 XP = Wc.XP = {}, // 通信协议v0.1 - 定义Wsdn的 XMPP Subset
    /*********************STAGE 3: 消息事件插槽**********************************/
    ES = eventslots = {
        B: function(eventname, delegates)
        {
            if (eventname && delegates) 
            {
                // 如果不存在eventname属性，构造之
                if (!ES.hasOwnProperty(eventname)) 
                {
                    ES[eventname] = [];
                }
                if (X.isA(delegates)) 
                {
                    var i, callback, isize = delegates.length;
                    for ( i = 0; i < isize; i++) 
                    {
                         callback = delegates[i];
                        if (X.isF(callback)) 
                        {
                            ES[eventname].push(callback);
                        }
                    }
                }
                else if (X.isF(delegates)) 
                {
                    ES[eventname].push(delegates);
                }
                
                return Tr;
            }
            return Fa;
        },
        T: function()
        {
            var a = arguments, args, delegates, isize, i;
            if (a.length == 0) 
            {
                return Fa;
            }
            if (a.length >= 1 && X.isVS(a[0])) 
            {
                delegates = ES[a[0]]; // 得到所有的triggee
                if (X.isA(delegates)) 
                {
                    args = null;
                    if (a.length > 1) 
                    {
                        args = Array.prototype.slice.call(a, 1); // 取出event的参数
                    }
                    else 
                    {
                        args = [];
                    }
                    try 
                    {
                        isize = delegates.length;
                        for (i = 0; i < isize; i++) 
                        {
                            delegates[i].apply(this, args);
                        }
                        
                        return Tr;
                    } 
                    catch (e) 
                    {
                        X.LOG(e);
                        return Fa;
                    }
                }
                else 
                {
                    return Fa; // 没有任何callback可以调用
                }
            }
            
            return Fa;
        }
    };    
    W.udp = udp; // Panel id pattern
    
    /**
     * 消息槽快捷调用
     * @namespace W.core.slots
     */
    W.T = ES.T;
    W.B = ES.B;
    
    /**
     * W.ui.slots 消息槽快捷调用
     * @namespace W.ui.slots
     * @param {String} eventname
     * @parma {Object} argument array
     */
    W.UST = function(eventname)
    {
        ES.T.apply(this, ["_uie_" + eventname].concat(Array.prototype.slice.call(arguments, 1)));
    };
    /**
     * W.ui.slots 消息槽快捷调用
     * @namespace W.ui.slots
     * @param {String} eventname
     * @param {Object} delegates
     */
    W.USB = function(eventname, delegates)
    {
        ES.B.apply(this, ["_uie_" + eventname].concat(Array.prototype.slice.call(arguments, 1)));
    };
    /**
     * W.user.ui.slots 消息槽快捷调用
     * @namespace W.user.ui.slots
     * @param {Object} eventname
     */
    W.UT = function(eventname)
    {
        ES.T.apply(this, ["_uuie_" + eventname].concat(Array.prototype.slice.call(arguments, 1)));
    };
    /**
     * W.user.ui.slots 消息槽快捷调用
     * @namespace W.user.ui.slots
     * @param {Object} eventname
     * @param {Object} delegates
     */
    W.UB = function(eventname, delegates)
    {
        ES.B.apply(this, ["_uuie_" + eventname].concat(Array.prototype.slice.call(arguments, 1)));
    };
			
    /********************STAGE 4：communication model***************************/  
    
    /*
     * 基本信息包 - 一般所有请求都会用到
     */
    var B = Wc.B = {
       
        /**
         * B 内部属性存取器
         */
        AC: function()
        {
            var rw = 0, // 0: read; 1: write
 			a = arguments, 
			n = EMPTY, 
			v = EMPTY, 
			isize = a ? a.length : 0;
            if (isize == 0) 
            {
                return EMPTY;
            }
            if (isize == 2) 
            {
                rw = 1;
                n = X.trim(a[0]);
                v = a[1];
            }
            if (isize == 1) 
            {
                rw = 0;
                n = X.trim(a[0]);
            }
            if (rw == 0) 
            {
                return B[n];
            }
            if (rw == 1) 
            {
                B[n] = v;				
            }
            return;
        },
        /**
         * 组合User Actions url请求
         */
        B: function(sel, type)
        {
            var r, u = [];
            u.push(['ic', B[PROPERTY_ROUNDTRIP_COUNTER].toString()].join('='));
            u.push(['w', B[PROPERTY_WSID]].join('='));
            u.push(['s', B[PROPERTY_SID]].join('='));
            u.push(['e', B[PROPERTY_RUNTIME_ENCODING]].join('='));			
            u.push(['l', B[PROPERTY_PREFERRED_LANGUAGE]].join('=')); 
			
			u.push(['adv',B[PROPERTY_ADVERT]].join('=')); //add by 罗标新 广告来源
			/**
			 * 2009-05-14 by gsyn77 - #149
			 */
			if (B[OBJECT_LIVEFX_LVT])
			{
				u.push([OBJECT_LIVEFX_LVT , B[OBJECT_LIVEFX_LVT]].join('='));
			}
			if (B[OBJECT_LIVEFX_CVT])
			{
				u.push([OBJECT_LIVEFX_CVT , B[OBJECT_LIVEFX_CVT]].join('='));
			}
			if (B[OBJECT_LIVEFX_VCT])
			{
				u.push([OBJECT_LIVEFX_VCT , B[OBJECT_LIVEFX_VCT]].join('='));
			}			 
			
			//add by luobx 2009-11-25 
			if (B[PROPERTY_ICON])
			{
				u.push([PROPERTY_ICON , B[PROPERTY_ICON]].join('='));
			}
			if (B[PROPERTY_WM])
			{
				u.push([PROPERTY_WM , B[PROPERTY_WM]].join('='));
			}
			// BUGFIXES #221 - 在每次保持连接请求参数中直接使用document.location、document.referrer
            // u.push('loc=' + ESC(B[PROPERTY_PAGE_LOCATION]));			
			// u.push('r=' + ESC(B[PROPERTY_PAGE_REFERER]));
			u.push(['loc', ESC(typeof(document.location) == udf ? EMPTY : document.location)].join('='));
			u.push(['r', ESC(typeof(document.referrer) == udf ? EMPTY : document.referrer)].join('='));
			
			// u.push('ti=' + ESC(X.doc().title)); // 2009-06-11 by gsyn77 #264
			if (Wi.WM != UI_WM_POP) { // since 2009-08-31 by gsyn77 - 弹出窗口不发送页面标题
				u.push(['ti', ESC(B[PROPERTY_DOCUMNET_TITLE])].join('=')); // 2009-06-11 by gsyn77 #264
			}
            // 当前界面使用类型：0 - 图标(默认)；1 - 小对话框；2 - 列表
            u.push(!X.isO(B[PROPERTY_UI_STYLE_CURRENT]) ? 'st=0' : ['st', B[PROPERTY_UI_STYLE_CURRENT]].join('='));
            // backend employee id
			if (X.isVS(B[PROPERTY_EID])) 
			{
				u.push(['eid', B[PROPERTY_EID]].join('='));
			}
            // backend employee online state
			if (X.isVS(B[PROPERTY_EMPLOYEE_STATE])) 
			{
				u.push(['state', B[PROPERTY_EMPLOYEE_STATE]].join('='));
			}            
            // backend employee addon-service state
            if (X.isVS(B[PROPERTY_EMPLOYEE_ADDONSERVICE])) 
            {
                u.push(['ado', B[PROPERTY_EMPLOYEE_ADDONSERVICE]].join('='));
            }            
			if (X.isVS(B[PROPERTY_USER_STATE_LAST])) 
			{
				u.push(['lu', B[PROPERTY_USER_STATE_LAST]].join('='));
			}		
            
            if (type && type == HTTP_METHOD_POST) 
            {
                r = {
                    p: B[PROPERTY_SERVICE_PORT_URL_ROOT] + B.ab[sel] + B.as[sel], // url path
                    m: HTTP_METHOD_POST, // method
                    d: EMPTY // data
                };
                r.d = u.join(STRING_CONNECTOR);
            }
            else 
            {
                // 用户键盘动作状态monitored
                if (B[PROPERTY_PRESENCE_FRONTIER] && (B[PROPERTY_PRESENCE_FRONTIER] != -1)) 
                {
					/**
					 * refs #232 - 支持（Js脚本中的）『文字预知』功能
					 */
                    u.push(['pa', ESC(B[PROPERTY_PRESENCE_FRONTIER].toString())].join('='));
                    B[PROPERTY_PRESENCE_FRONTIER] = -1; // 输出后置位
                }
                u.push(['u', B[PROPERTY_USER_STATE]].join('='));
				/**
				 * BUGFIXES #221: 加固算法 - 将上次提交时间发到服务器端
				 */
				if (X.isO(B[PROPERTY_LAST_TICKS]))
				{
					u.push(['lt', B[PROPERTY_LAST_TICKS].toString()].join('=')); 
				}				
	            /**
	             * BUGFIXES #221: 加固算法 - 记录本次提交时间以便下次使用
	             */
	            B[PROPERTY_LAST_TICKS] = X.ticks();
				/**
				 * BUGFIXES #221: 加固算法 - 将上次收到服务器端响应的时间发到服务器端
				 */
				if (X.isO(B[PROPERTY_LAST_ACK]))
				{
					u.push(['la', B[PROPERTY_LAST_ACK].toString()].join('=')); 
				}
				/**
				 * BUGFIXES #221: 加固算法 - 标识当前动作为guard —— 维护在线状态
				 */
				if ( B[PROPERTY_GUARD] && B[PROPERTY_GUARD] == 1 )
				{
					u.push(['guard', B[PROPERTY_GUARD].toString()].join('='));
				}
                /**
                 * 随机数 - 保证 HTTP GET 请求不受浏览器缓存机制影响 并且可作为计时器使用 - 应该是1970年1月1日
                 * 00:00:00 至今的毫秒数
                 */
                u.push(['t', X.ticks().toString()].join('=')); // BUGFIXES #221: 加固算法 - 保持最后提交时间
                if (B[PROPERTY_CHAT_REQUEST_TIME_LAST] != -1) 
                {
                    u.push(['bt', B[PROPERTY_CHAT_REQUEST_TIME_LAST]].join('='));
                }
                r = [B[PROPERTY_SERVICE_PORT_URL_ROOT] , B[PROPERTY_SERVICE_PORT_ACTIONBASE][sel] , B[PROPERTY_SERVICE_PORT_ACTIONOPERATOR][sel] , STRING_CONNECTOR , u.join(STRING_CONNECTOR)].join(EMPTY);
            }
            try 
            {
                delete u;
                u = null;
            } 
            catch (e) 
            {
                X.LOG(e);
            }
            
            return r;
        },
        /**
         * round-trip counter validate and increment
         * client发送偶数，server返还奇数：可以用于同步状态 - server - 1 >= client
         */
        I: function()
        {
            B[PROPERTY_ROUNDTRIP_COUNTER]++;
            return;
        },
		/**
		 * start round-trip 
		 */
        T: function()
        {
			/**
             * BUGFIXES #221: 加固算法 - 启动每隔指定直接（默认为1秒钟）检查与服务器端通信
             *   是否正常“接力”，如果没有则立即提交保持连接命令字；
             *   2009-04-22 modified by gsyn77 - 将Guard动作放到B.B(CMD_ENTER)动作之前
             */
            B.I(); // start round-trip counter
			
            X.xpt(B.B(CMD_ENTER));
			/**
             * BUGFIXES #221: 加固算法 - 保持首次提交响应时间：用于防止首次提交即超时掉线的情况（访客网络极差）
             * 实际上应该没有多少延时，因为B.B(CMD_ENTER)应该是异步提交并返回的
             */			
			B[PROPERTY_LAST_ACK] = X.ticks();
			
			B.G();
            return;
        },
        /**
         * 根据场景切换User-State，并由下一次keep动作将这一转换后的状态发送到系统
         */
        CA: function()
        {
            if (B[PROPERTY_USER_STATE] == PROPERTY_VALUE_USERSTATE_TW) // 如果接收到invitation
            {
                B[PROPERTY_USER_STATE_LAST] = B[PROPERTY_USER_STATE];
                B[PROPERTY_USER_STATE] = PROPERTY_VALUE_USERSTATE_TR; // user refuse invitation
            }
            else if (B[PROPERTY_USER_STATE] == PROPERTY_VALUE_USERSTATE_TC) // 如果处于对话请求状态
            {
                B[PROPERTY_USER_STATE_LAST] = B[PROPERTY_USER_STATE];
                B[PROPERTY_USER_STATE] = PROPERTY_VALUE_USERSTATE_TN; // user cancels communication request
            }
            else if (B[PROPERTY_USER_STATE] == PROPERTY_VALUE_USERSTATE_C || B[PROPERTY_USER_STATE] == PROPERTY_VALUE_USERSTATE_CX) // 如果处于对话状态
            {
                B[PROPERTY_USER_STATE_LAST] = B[PROPERTY_USER_STATE];
                B[PROPERTY_USER_STATE] = PROPERTY_VALUE_USERSTATE_CI; // user closes/minimizes chat-window
            }
            return;
        },
        /**
         * Begin Chat - server invokes
         *
         * 必须完成的任务包括：
         * 	1. 将 buffered消息 发送给system
         *  2. 如果 type == 'CX' 则根据情况在Browser中显示‘正在进行短信沟通……’之类的系统提示
         *
         * @param type -
         *        string, chat types: "C" online, "CX" xms
         */
        BC: function(type)
        {
            if (type && (type == PROPERTY_VALUE_USERSTATE_C || type == PROPERTY_VALUE_USERSTATE_CX)) 
            {
                B[PROPERTY_USER_STATE_LAST] = B[PROPERTY_USER_STATE]; // buffer last user state
                B[PROPERTY_USER_STATE] = type;
                //////////////////////////////////////
                // 1. 将 buffered消息 发送给system
                //////////////////////////////////////
				if (type == PROPERTY_VALUE_USERSTATE_C) 
				{
					// BUGFIX by gsyn77 2009-06-19: 后台提示上线时没有存储B[PROPERTY_USER_STATE_LAST]
					if (B[PROPERTY_USER_STATE] == PROPERTY_VALUE_USERSTATE_CX )
					{
						B[PROPERTY_USER_STATE_LAST] = PROPERTY_VALUE_USERSTATE_CX
						B[PROPERTY_USER_STATE] = PROPERTY_VALUE_USERSTATE_TC;
					}
					var mb, u = [], p = B.B('chat', HTTP_METHOD_POST);
					u.push(p.d);
					mb = B[PROPERTY_USER_MSG_BUFFER].join(EMPTY);
					if (X.isVS(mb)) 
					{
						u.push('bf=' + mb); // bufferred msg to show on backend chat screen
					}
					u.push('bt=' + B[PROPERTY_CHAT_REQUEST_TIME_LAST]); // 发送：chat-request请求的起始时间
					u.push('u=' + B[PROPERTY_USER_STATE]); // 发送：当前user-state
					p.d = u.join(STRING_CONNECTOR);
					delete u;
					u = null;
					X.post(p.p, p.d); // 对话内容发送到System
				}
                //////////////////////////////////////
                // 2. 如果 type == 'CX' 则根据情况在
                // Browser中显示‘正在进行短信沟通……’之类的系统提示
                //////////////////////////////////////                
            }
            return;
        },
        /**
         * End Chat - server invokes
         */
        EC: function()
        {
            B[PROPERTY_USER_STATE_LAST] = B[PROPERTY_USER_STATE]; // buffer last user state
            B[PROPERTY_USER_STATE] = PROPERTY_VALUE_USERSTATE_CI;
            return;
        },
        /**
         * 构造chat动作的数据格式
         * @param {Object} msg
         * @param {Object} us - 可选参数，用于指定发送消息时的USER_STATE since 2009-08-31 by gsyn77 - 用于防止在发送留言后发送联系方式
         */
        BCT: function(msg,us)
        {
            var tmp, a = arguments, m = EMPTY, p, u, mb;
            
            if (a.length >= 1) 
            {
                tmp = a[0];
                if (typeof tmp == usf) // user messages sent
                {
                    m = tmp;
                }
            }
            else 
            {
                return;
            }
            
            p = B.B('chat', HTTP_METHOD_POST), u = [];
            u.push(p.d);
            // if usr sent non-empty messges
            if (X.isVS(m)) 
            {
                B[PROPERTY_USER_MSG_CURRENT] = ESC(X.clear(m)); // 清空HTML标签并转码消息内容
                u.push('m=' + B[PROPERTY_USER_MSG_CURRENT]);
            }
			if(X.isVS(us))
			{
				B[PROPERTY_USER_STATE] = us;
			}
            /*
             * 如果处于对话中
             */
            if (B[PROPERTY_USER_STATE] == PROPERTY_VALUE_USERSTATE_C || B[PROPERTY_USER_STATE] == PROPERTY_VALUE_USERSTATE_CX) 
            {
                B[PROPERTY_USER_MSG_CURRENT] = EMPTY; // clear current messages
                B[PROPERTY_USER_MSG_BUFFER] = []; // clear buffered messages
                B[PROPERTY_CHAT_REQUEST_TIME_LAST] = -1; // reset last chat request time
            }
            else 
            {
                if (B[PROPERTY_USER_STATE] != PROPERTY_VALUE_USERSTATE_TC) 
                {
                    B[PROPERTY_USER_STATE_LAST] = B[PROPERTY_USER_STATE]; // buffer last user state
                    B[PROPERTY_USER_STATE] = PROPERTY_VALUE_USERSTATE_TC; // wait backend reception
                    B[PROPERTY_CHAT_REQUEST_TIME_LAST] = X.ticks(); // set last chat request time
                }
                if (typeof B[PROPERTY_USER_MSG_BUFFER] == udf) 
                {
                    B[PROPERTY_USER_MSG_BUFFER] = [];
                }
                B[PROPERTY_USER_MSG_BUFFER].push(B[PROPERTY_USER_MSG_CURRENT]);
                B[PROPERTY_USER_MSG_CURRENT] = EMPTY;
                mb = B[PROPERTY_USER_MSG_BUFFER].join(EMPTY);
                if (X.isVS(mb)) 
                {
                    u.push('bf=' + mb); // bufferred msg to show on backend chat screen
                }
            }
            u.push('bt=' + B[PROPERTY_CHAT_REQUEST_TIME_LAST]); // 发送：chat-request请求的起始时间
            u.push('u=' + B[PROPERTY_USER_STATE]); // 发送：当前user-state
            p.d = u.join(STRING_CONNECTOR);
            delete u;
            u = null;
            
            return p;
        },
        /**
         * 发送msg - usr invokes
         *
         * @argument msg - string, msg to sent
         */
        CT: function(msg)
        {
            var p = B.BCT(msg);
            X.post(p.p, p.d); // 对话内容发送到System
            return;
        },
        /**
         * 负责发送‘电话’
         * @param {Object} data
         */
        CL: function(data)
        {
            var prop, p = B.B('call'), u = [];
            u.push(p);
            for (prop in data) 
            {
                if (data.hasOwnProperty(prop) && X.isVS(data[prop])) 
                {
                    u.push(prop + "=" + data[prop]);
                }
            }
            p = u.join(STRING_CONNECTOR);
            delete u;
            u = null;
            // X.post(p.p, p.d); // 将‘电话’请求信息发送给system
            return p;
        },
        /**
         * 负责发送‘联系方式’
         * @param {Object} data
         */
        CTC: function(data)
        {
            var prop, p = B.BCT(EMPTY,PROPERTY_VALUE_USERSTATE_C), u = [];
            u.push(p.d);
            // 将‘联系方式’中的非空数据项加入到contact参数中
            for (prop in data) 
            {
                if (data.hasOwnProperty(prop) && X.isVS(data[prop])) 
                {
                    u.push(prop + "=" + ESC(data[prop]));
                }
            }
            // 加入‘联系方式’标识位，表示这是一个特殊的‘chat’动作请求
            u.push('_ct_=1');
            p.d = u.join(STRING_CONNECTOR);
            delete u;
            u = null;
            X.post(p.p, p.d); // 将‘留言’或‘联系方式’发送给system
            return;
        },
        /**
         * 发送留言
         * @param {Object} data
         */
        N: function(data)
        {
            // 如果data.msg不为空，说明是留言
            // ‘留言’触发条件为：对话（包括短信）超时，此时状态应该变为TT，即没有成功进行过对话所以不是CI
            if (X.isVS(data.msg)) 
            {
                B[PROPERTY_USER_STATE_LAST] = B[PROPERTY_USER_STATE];
                B[PROPERTY_USER_STATE] = PROPERTY_VALUE_USERSTATE_TT;
            }
            var prop, p = B.B('note', HTTP_METHOD_POST), u = [];
            u.push(p.d);
            for (prop in data) 
            {
                if (data.hasOwnProperty(prop) && X.isVS(data[prop])) 
                {
                    u.push(prop + "=" + ESC(data[prop]));
                }
            }
            p.d = u.join(STRING_CONNECTOR);
            delete u;
            u = null;
            X.post(p.p, p.d); // 将‘留言’发送给system
            return;
        },
        /**
         * 『Obsoleted』 改由server端检查并输出
         * @param {Object} callback
         */
        LI: function(callback)
        {
            // 主动方法 - client invoke
            X.post(B.B('list'), null, callback);
        },
        /**
         * 恢复keep
         */
        R: function()
        {
			B['_ksr_'] = 0; //2009-06-19 by gsyn77 #227 - 增加对弹出窗口模式下断续主页面连接的支持
            B.K(0);
        },
        /**
         * 暂停keep
         */
        S: function()
        {
			B['_ksr_'] = -1; //2009-06-19 by gsyn77 #227 - 增加对弹出窗口模式下断续主页面连接的支持
            B.K(-1); 
        },
		/**
		 * #279 - 針對1個彈出對話窗口~多個流覽頁面情況，使用第一方Cookie方式檢查當前彈出窗體狀態：打開、關閉
		 * 定时（2秒）检查弹出窗口状态，如果已经关闭则恢复keep
		 * @param {Object} popW
		 */
		W: function(popW){
            function checkPopWin()
            {
                try 
                {
                 	X.atc(popWH); // 删除定时器
					/**
					 * #279 - 針對1個彈出對話窗口~多個流覽頁面情況，使用Flash Cookie方式檢查當前彈出窗體狀態：打開、關閉
					 * 同時檢查彈出窗口句柄和FlashCookie中的標誌
					 * since 2009-07-10 by gsyn77
					 *
					 * modify by luobx 2010-09-11 弹出窗口页面设置的                     * 的 flashcook 值,父页面或取不到 
					 * 使用 Ui.$PopWin.closed + !W.Fxcwid() 来判断           
                     */
					if (Ui.$PopWin.closed || !W.Fxcwid()) //!W.Fxcwid()
					{
						B.R();
					}
                    else 
                    {
                        // X.atc(popWH); // 删除定时器 - FIXME: 内存泄漏
                        popWH = X.at(function()
                        {
                            checkPopWin();
                        }, 2000);
                    }
                } 
                catch (e) 
                {
                    X.LOG(e);
                    B.R(); // 出现异常时，假设弹出窗口已经关闭
                }
            }
            var popWH = X.at(function()
			{
				checkPopWin();
			}, 2000);			
		},
        /**
         * 主动方法 - client invoke
         */
        K: function(data)
        {	                      
            if (data == -1) // suspend keep 
            {
                B['kv'] = 0;
				X.atc(B['kh']);
				return;
            }
            else if (data == 0) // resume keep
            {
                B['kv'] = DEFAULT_KEEPONLINE_INTERVAL;
            }
			else if (!X.isO(data)) 
            {
                return;
            }
            else // normal keep 
            {
				/**
				 * BUGFIXES #221: 加固算法 - 设置服务器端“接力”状态为『正常』
				 *  使用timestamp作为标识位
				 */
			 	B[PROPERTY_LAST_ACK] = X.ticks();
                B[PROPERTY_ROUNDTRIP_COUNTER] = parseInt(data.rtc);				
                B[PROPERTY_SID] = data.sid;
				// 如果间隔时间不存在，则使用系统设定；否则，使用原有值或本地G()计算值
				if (!X.isO(B['kv'])) 
				{
					B['kv'] = data.kv;
				}
            }
            
			if (!X.isO(B['ackTask']))
			{
				B['ackTask'] = [];
			}
			B['ackTask'].push(X.ticks());			
        },
        /**
         * 负责检查维护keep动作
         * 2009-06-19 by gsyn77 #227 - 增加对弹出窗口模式下断续主页面连接的支持
         */
        G: function(){
            X.rt(function(){
                /**
                 * #279 
                 * - 如果Flash Cookie中說明有彈出對話窗口沒有關閉，則啟動動態檢查
                 * - 將當前窗體id和當前訪客最後鎖定窗體（outbouncer）id提交給服務器
                 * 	- 如果這兩個id相同，表示訪客當前正在流覽該窗體內容
                 * 	- 如果不相同，則以 outbouncer id 為主
                 */
                var cond = true;
                try {
					/**
					 * 优先级从高到低排列：
					 * - 判断是否当前弹出窗口；
					 * - 当前没有任何弹出窗口 -> 当前focus窗口就是self；
					 */
					if (Wi.WM == UI_WM_POP)
					{
						cond = true;
					}
					else
					{
						cond = ( W.Fxcwid(Wi.winid, true) || Ui.$PopWin.closed || !W.Fxcwid()) ? Wi.lockat(Wi.winame) == Wi.winid : false;
					}                    
                } 
                catch (ex) {
                    cond = true;
                }
				// DEBUG INFO
				if (X.DEBUG) document.title = ['cond = ' , cond].join('');
                if (!cond) return;
				// DEBUG INFO
				if (X.DEBUG) document.title = [Wi.lockat(Wi.winame),'Gi run at - ', X.Time()].join('|');
				
                var tSpan = X.ticks() - B[PROPERTY_LAST_ACK];
                function Gi(){
                    B.I(); // run round-trip counter
                    X.xpt(B.B('keep'));
                    /*
                     * 2009-05-04 commented by gsyn77
                     * - 总体而言网络延迟应该是一个较长时间范围（相对于访客会话流程）内发生的问题，因此一旦发生就没有取消的必要
                     */
                    // B[PROPERTY_GUARD] = 0; 
                }
                /*
                 * 2009-06-19 by gsyn77 #227
                 * keep online resumed from suspended
                 */
                if (B['_ksr_'] == 0) {
                    B['_ksr_'] = '';
                    tSpan = 0;
                }
                if (B['ackTask'] && B['ackTask'].length > 0) {
                    if (B['kh']) {
                        X.atc(B['kh']);
                    }
                    B['ackTask'] = [];
                    if (!X.isO(B['arAck'])) {
                        B['arAck'] = [];
                    }
                    if (tSpan > DEFAULT_KEEPONLINE_INTERVAL + DEFAULT_GUARD_INTERVAL) {
                        B['arAck'] = []; // 如果某次超时，清空记录数
                        B[PROPERTY_GUARD] = 1;
                        B['kv'] = DEFAULT_KEEPONLINE_INTERVAL * 0.1; //             
                    }
                    else {
                        if (B['arAck'].length > 10) {
                            B['arAck'] = []; // 
                            B['kv'] = DEFAULT_KEEPONLINE_INTERVAL;
                        }
                        B['arAck'].push(tSpan);
                    }
                    B['kh'] = X.at(Gi, B['kv']);
                }
                
            }, DEFAULT_GUARD_INTERVAL);         
        },
		/**
		 * 發送上傳文件完畢事件通知給後臺接待人員
		 * @param {Object} n
		 */
        Fu: function(n)
        {
			if (X.isVS(n)) 
			{
				var p = B.B('chat', HTTP_METHOD_POST), u = [];
				u.push(p.d);
				u.push('_fxu_=' + n); // 獲取已經上傳的文件名稱（不包括路徑）
				u.push('u=' + B[PROPERTY_USER_STATE]);
				p.d = u.join(STRING_CONNECTOR);
				delete u;
				u = null;
				
				X.post(p.p, p.d); // 發送上傳文件完畢事件通知給後臺接待人員
			}
        },
		/**
		 * 2009-06-11 by gsyn77 #264
		 * Slot a Message
		 * @param {Object} m - message to slot
		 */
		SM: function(m){
			B[PROPERTY_MESSAGE_SLOT] = X.ticks().toString() + '|' + m;
		},
		/**
		 * 2009-06-11 by gsyn77 #264
		 * Pop a Slot Messsage
		 */
        PM: function()
        {
			// 如果沒有處於對話狀態直接返回
			if (!(B[PROPERTY_USER_STATE] == PROPERTY_VALUE_USERSTATE_C || B[PROPERTY_USER_STATE] == PROPERTY_VALUE_USERSTATE_CX)) {
				return;
			}
            var args = B[PROPERTY_MESSAGE_SLOT] ? B[PROPERTY_MESSAGE_SLOT].split('|') : EMPTY;
            
            if (X.isVS(args[0]) && args[0] != B[PROPERTY_WINDOW_FOCUS_TIMESTAMP]) {
                StartBlinkDocumentTitle(args[1]);
                B[PROPERTY_WINDOW_FOCUS_TIMESTAMP] = args[0];
            }
        }
    };
	/**
	 * #264
	 */
    function StartBlinkDocumentTitle(m){
        X.rtc(B['hBT']);
        B[PROPERTY_DOCUMENT_TITLE_BLINK_STATUS] = true;
        
        B['hBT'] = X.rt(function(){
            var t = EMPTY;
            if (B[PROPERTY_DOCUMENT_TITLE_BLINK_STATUS]) {
                t = m;
            }
            else {
                t = B[PROPERTY_DOCUMNET_TITLE];
            }
            if (X.isVS(t)) {
                document.title = X.clear(UEC(t),' ');
            }
            B[PROPERTY_DOCUMENT_TITLE_BLINK_STATUS] = !B[PROPERTY_DOCUMENT_TITLE_BLINK_STATUS];
        }, 1500);
    }
    
    function EndBlinkDocumentTitle(){
       	X.rtc(B['hBT']);
        B[PROPERTY_DOCUMENT_TITLE_BLINK_STATUS] = false;
        document.title = B[PROPERTY_DOCUMNET_TITLE];
    }
    
    
    /**
     * url root path - http://live.webeye.net.cn/v8/, etc.
     */
    B[PROPERTY_SERVICE_PORT_URL_ROOT] = EMPTY;
    // action base
    B[PROPERTY_SERVICE_PORT_ACTIONBASE] = {    
        'enter': SERVICE_PORT_PREFIXER,
        'keep': SERVICE_PORT_PREFIXER,
        'chat': SERVICE_PORT_PREFIXER,
        'call': SERVICE_CALL_PREFIXER,
        'note': SERVICE_PORT_PREFIXER,
		'pop': SERVICE_POP_CHAT_PREFIXER
    };
    // actions ops
    B[PROPERTY_SERVICE_PORT_ACTIONOPERATOR] = {
        'enter': "a=0",
        'keep': "a=1",
        'chat': "a=100",
        'call': "a=101",
        'note': "a=102"
    };
    B[PROPERTY_WSID] = EMPTY; // 站点唯一编号
    B[PROPERTY_SID] = EMPTY; // 访客唯一标识
    B[PROPERTY_RUNTIME_ENCODING] = X.enc; // 当前页面的runtime编码方式
    B[PROPERTY_PREFERRED_LANGUAGE] = X.lang; // 当前浏览器的“首选语言”
    B[PROPERTY_PAGE_LOCATION] = X.location; // 当前页面的location.href
    B[PROPERTY_PAGE_REFERER] = X.refer; // 当前页面的referer
    B[PROPERTY_ROUNDTRIP_COUNTER] = -1; // round-trip counter
    B[PROPERTY_ADVERT] = X.advert(); //广告来源
    /**
     * User-State:
     * #0	Tour(T)  					-	一般浏览状态
     * 		Tour(TW) 					-	浏览过程中接收到invitation
     * #1 	Tour-Communicate(TC)		-	请求对话
     * 		Tour-Call(TP)				-	打开电话拨叫面板
     * 		Tour-Cancel(TN)				-	取消对话请求
     * 		Tour-Refuse(TR) 			-	拒绝invitation
     * 		Tour-Request-Timeout（TT）	-	请求（对话、电话）并未接通并且超时
     * #2	Communicating(C) 			-	对话中
     * 		Communicate Xms(CX)			-	Xms对话中
     * #3	Comm-Interval(CI)			-	结束了对话状态，继续浏览，后面有可能继续对话
     */
    B[PROPERTY_USER_STATE] = PROPERTY_VALUE_USERSTATE_T;
    /**
     * Last User-State
     */
    B[PROPERTY_USER_STATE_LAST] = EMPTY;
    /**
     * user messges bufferred before communication channel built and sent to
     * backends
     */
    B[PROPERTY_USER_MSG_BUFFER] = [];
    /**
     * current user input message
     */
    B[PROPERTY_USER_MSG_CURRENT] = EMPTY;
    /**
     * last chat request time
     */
    B[PROPERTY_CHAT_REQUEST_TIME_LAST] = -1;
    B['kv'] = DEFAULT_KEEPONLINE_INTERVAL;
    B['kh'] = null;
	

    /**
     * 应用场景下的公开方法
     *
     * @namespace W.core
     */
	/**
	 * 
	 */
	Wc.B = B;
	/**
	 * 
	 */
    Wc.ac = B.AC;
    /**
     * change ‘User-State’ and backup old state
     * @param {Object} us
     */
    Wc.cu = function(us)
    {
        if (X.isVS(us)) 
        {
            B.AC(PROPERTY_USER_STATE_LAST, B.AC(PROPERTY_USER_STATE));
            B.AC(PROPERTY_USER_STATE, X.trim(us));
        }
    };
    /**
     * 负责清空_bag属性
     * @param {Object} pn
     */
    Wc.rm = function(pn)
    {
        if (X.isVS(pn)) 
        {
            B.AC(pn, EMPTY);
        }
    };
    /**
     * 负责将前后台对话消息缓存到本地，或者是读取本地缓存消息
     * @param {Object} msg 需要缓存的消息内容，如果没有该参数则表示需要提取以前缓存的消息
     */
    Wc.cm = function(msg)
    {
		/*
        var eid = B.AC(PROPERTY_EID), key = 'localmsg_', nobody = B.AC(key), // 检查是否有对话接通前的消息被缓存
 isList = Wc.ac('list'); // 判断当前是否为list模式
        if (nobody) 
        {
            B.AC(key, EMPTY); // 清空对话接通前缓存的消息
        }
        if (eid && isList && typeof isList == udb) 
        {
            key += eid; // 获取专属于某个eid的缓存消息
        }
        
        if (X.isVS(msg)) 
        {
            B.AC(key, nobody ? nobody + msg : msg);
        }
        else 
        {
            return B.AC(key);
        }
        */
		// 简化为存储所有对话内容
		var key = 'localmsg_';
		if (X.isVS(msg)) 
        {
            B.AC(key, msg);
        }
        else 
        {
            return B.AC(key);
        }
    };
    
    /***********************STAGE 5：Polygon WebParts**************************/
    /**
     * Drag & Drop
     *
     * @param {Function} callback - function called in polygon moving and drop
     * 	moving: callback('move',newLeftPixel, newTopPixel)
     * 	drop:	callback('drop')
     */
    var DDr = function(callback)
    {
        var evtMouseMove = null, evtMouseUp = null, dragObject = null, mouseOffset = null;
        
        function mouseCoords(ev)
        {
            if ((ev.pageX || ev.pageY))
            {
                return {
                    x: ev.pageX,
                    y: ev.pageY
                };
            }
            // FIXME: 这里可能会出错
            return {
                x: ev.clientX + document.body.scrollLeft - document.body.clientLeft,
                y: ev.clientY + document.body.scrollTop - document.body.clientTop
            };
        }
		function mouseCoordsRelative(ev)
		{			
            return {
                x: ev.clientX,
                y: ev.clientY
            };
		}
        function getMouseOffset(target, ev)
        {
            ev = ev || window.event;
            
            var docPos = getPosition(target), mousePos = mouseCoords(ev);
            return {
                x: mousePos.x - docPos.x,
                y: mousePos.y - docPos.y
            };
        }
        
        function getPosition(e)
        {
            var left = 0, top = 0;
            
            while (e.offsetParent) 
            {
                left += e.offsetLeft;
                top += e.offsetTop;
                e = e.offsetParent;
            }
            
            left += e.offsetLeft;
            top += e.offsetTop;
            
            return {
                x: left,
                y: top
            };
        }
        
        function mouseMove(ev)
        {
            ev = ev || window.event;
            var mousePos = mouseCoords(ev), axis, top, left, rtop;
            
            if (dragObject) 
            {
				if (!X._useFix) 
				{
					dragObject[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_POSITION] = STYLE_VALUE_ABSOLUTE;
				}
				
                top = mousePos.y - mouseOffset.y;
				left = mousePos.x - mouseOffset.x;
				
				axis = SurroundClientArea(dragObject, top, left);
				left = axis.x;
				top = axis.y;
				rtop = axis.ry;
				
                dragObject[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_TOP] = (top).toString() + STYLE_UNIT_PX;
				
				/**
				 * BUGFIXES #222 - 火狐下拖动后再最小化停留位置出现问题
				 * 修正 - 只能上下拖曳
				 */
				if (X.msie7) 
				{
					dragObject[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_LEFT] = (left).toString() + STYLE_UNIT_PX;
				}
				
                if (X.isF(callback)) 
                {
					top = ev.clientY;
					left = parseInt(dragObject[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_LEFT]);
                    callback.apply(this, ['move', (rtop || top), left]);
                }
                
                return Fa;
            }
        }
        
        function mouseUp()
        {
            document.onmousemove = evtMouseMove;
            document.onmouseup = evtMouseUp;
            
            dragObject.onmousedown = null;
            
            dragObject = null;
            mouseOffset = null;
            
            if (X.isF(callback)) 
            {
                callback.apply(this, ['drop']);
            }
        }
        
        function _onmousedown(ev)
        {
            evtMouseMove = document.onmousemove;
            evtMouseUp = document.onmouseup;
            document.onmousemove = mouseMove;
            document.onmouseup = mouseUp;
            
            mouseOffset = getMouseOffset(dragObject, ev);
            return Fa;
        }
        /**
         * Make item draggable
         * @param {Object} holder	触发DragDrop的Element或Element id
         * @param {Object} item		被DragDrop的Element或Element id
         */
        this.makeDraggable = function(holder, item)
        {
            if (!item || !holder) 
            {
                return;
            }
            if (X.isVS(holder)) 
            {
                holder = X.$(holder);
            }
            if (X.isVS(item)) 
            {
                item = X.$(item);
            }
            if (!item || !holder) 
            {
                return;
            }
            
            dragObject = item;
            dragObject.onmousedown = _onmousedown;
        };
    },    /**
     * 多边形定位管理类
     */
    wP = {
        loading: Fa, // 用于判断是否正在通过windownameframe加载界面
        timeH: null, // setInterval() handler
        timeI: 400, // millisecond
        panels: {}, // 不同状态对应的Panel-Dom Object
        miscs: {}, // 用于加载如request等独立‘模态’界面
        lastMode: [], // 用作stack保留以往mode切换状态
        currentModal: EMPTY, // 当前‘模态’界面名称
        dragModal: EMPTY, // 当前Drag&Drop的‘模态’名称       
        /**
         * find Parent Polygon
         * @param {Object} did
         * @param {Object} pid
         */
        fpp: function(did, pid)
        {
            var pnode = did;
            if (X.isS(pnode)) 
            {
                pnode = X.$(pnode).parentNode;
            }
            while (pnode && (!X.isO(pnode.id) || pnode.id.indexOf(pid) < 0))
            {
                pnode = pnode.parentNode;
            }
            return pnode;
        },
        /**
         * 多边形 Drag & Drop
         * @param {String} did - dragging element id
         */
        drag: function(did)
        {
            if (!did) 
            {
                return;
            }
            var holder = typeof did == usf ? X.$(did) : did, dropper, dd;
            if (!holder) 
            {
                return;
            }
            
            dropper = wP.fpp(holder, udp); // find Parent Polygon
            wP.dragModal = dropper.id.replace(udp, EMPTY).replace(/_(\d+)$/gi, EMPTY);
            
            dd = new DDr(function(type, top, left)
            {
                var pg = wP.get(wP.dragModal);
                if (type == 'move') 
                {
                    wP.fly(-1); //
                    if (top) 
                    {
                        if (pg) 
                        {	
							/**
		                     * BUGFIXES #222 - 将受影响的center替换为random，一般只替换y坐标上的center
		                     */
		                    pg[TAG_ATTRIBUTE_STYLE]['attach'] = pg[TAG_ATTRIBUTE_STYLE]['attach'].replace('center', 'random');                    		
                            //pg[TAG_ATTRIBUTE_STYLE]['attach'] = 'random'; // make Drag & Drop
                            //pg[TAG_ATTRIBUTE_STYLE]['x'] = left;
                            pg[TAG_ATTRIBUTE_STYLE]['y'] = top;
                        }
                    }
                }
                
                if (type == 'drop') 
                {
                    wP.fly();
                }
            });
            
            dd.makeDraggable(holder, dropper);
        },
        /**
         * 获得当前缓存的历史状态数量
         */
        history: function()
        {
            return lastMode.length;
        },
        /**
         * 返回当前modal
         */
        current: function()
        {
            return wP.panels[wP.currentModal];
        },

        /**
         * 切换不同界面状态mode下的Panel
         * 流程：将上次mode推栈，清空对应的DomObject；然后设置当前mode，并加载对应界
         * 面source，如果该source没有缓存则从来源url加载之。
         * @param {Object} uimode，比如 request, min, max, normal or popwin
         */
        TG: function(uimode)
        {
            var a = arguments, ui = wP, b = Ui, 
			urlbase = Ui.urlbase, 
			lastmode, lastmodal, 
			pp, 
			callback = null, 
			pg, param = [], 
			ic = 0, 
			prop, 
			br;
            
            /*
             * 如果没有指定显示Mode，那么退回上一个Mode界面状态
             */
            if (!X.isVS(uimode)) 
            {
                lastmode = ui.lastMode.pop();
                lastmodal = ui.get(lastmode);
                if (X.isO(lastmodal)) 
                {
                    ui.TG(lastmode);
                }
                return;
            }
            
            pp = b[uimode];
            // Specified ui modal does not exists
            if (!X.isO(pp)) 
            {
                return;
            }
            //判断是否在调用toggle时使用了callback            
            if (arguments.length == 2 && X.isF(arguments[1])) 
            {
                callback = arguments[1];
            }
			/*
             * 加载最新状态界面
             */
            pg = ui.get(uimode);
			
            // 如果需要切换的‘模态’界面名称与当前相同，则不做任何处理直接返回
            if (uimode == wP.currentModal) 
            {
                pg.load(uimode, uiswitch);
                return;
            }
            
            // 如果指定mode界面source已经存在则加载并重新显示、构造其Dom之
            if (X.isO(pg)) 
            {
                pg.load(uimode, uiswitch);
            }
            else 
            {
                // 否则从url源获取并加载之                
                if (!X.isVS(pp.url)) 
                {
                    //X.LOG("specified ui-mode url invalidate");
                    return;
                }
                
				/*
				 * BUGFIXES 2009-05-07 by gsyn77 - 防止Js注入导致的属性不一致错误
				 param.push(uimode);
                for (prop in pp) 
                {
                    param.push(pp[prop]);
                    ++ic;
                    if (ic > 9) 
                    {
                        break;
                    }
                }
                */
				
                pg = ui.build(uimode, pp);
                ui.panels[uimode] = pg; //不同状态对应的Panel-Dom Object                
                pg.T(uimode, pp.url, uiswitch); // 
                
				if (Wi.WM != UI_WM_POP) { // 弹出过窗口不使用iso.css since 2009-08-28
					// #275 -  since 2009-08-05 by gsyn77
					X.xss([Ui.urlbase, 'iso.css'].join(''));
				}
                /**
                 * TODO: CSS相關配置應該在U.uimodel中配置
                 */
                br = (X.br.msie ? (X.msie6 ? "ie" : "ie7") : "ff");
				var place = Wc.ac(UI_PLACE);
				if ((place == 8 || place == 9) && X.msie)
				{                    
                    if (X.quirks) {
                        X.xss([pp.stylesheet[br].replace('.css', ''), '_quirks.css'].join(''), urlbase);
                    }
                    else {                    
                        if (X.msie6) {
                            X.xss([pp.stylesheet[br].replace('.css', ''), '_ie6.css'].join(''), urlbase);
                        }
                        else if (X.msie8) {
                            X.xss([pp.stylesheet[br].replace('.css', ''), '_ie8.css'].join(''), urlbase);
                        }
						else
						{
							X.xss(pp.stylesheet[br], urlbase);
						}
                    }						
				}
				else
				{
					X.xss(pp.stylesheet[br], urlbase);
				}
                
                X.xpt(pp.javascript, urlbase);
            }
            
            /*
             * 切换当前状态 - 用在load()或touch()方法执行结束之后，以便串行化界面显示与控制
             */
            function uiswitch()
            {
                if (X.isF(callback)) 
                {
                    callback.apply(this);
                }
                var becomeOld = ui.currentModal, // 获得当前mode
                sinkModal;
                if( X.isVS(becomeOld) && becomeOld != uimode)
				{
					sinkModal = ui.get(becomeOld); // 得到当前mode对应的PanelObject
					ui.lastMode.push(becomeOld); // 入栈
					if (X.isO(sinkModal)) 
					{
						sinkModal.sink(becomeOld); // 让其清空显示界面和Dom nodes 以避免多个界面相同功能元素id的混淆
					}
				}
                ui.currentModal = uimode; // 设置当前mode为新指定的mode		
                ui.fly();
            }
        },
        /**
         * 构造polygon（panel），并进行登记管理
         * @param {String} mode			-	panel 对应的ui modal：request, min, normal, max, popwin
         * @param {String} id			-	panel layer id
         * @param {Number} x			-	panel layer position.x
         * @param {Number} y			-	panel layer position.y
         * @param {String} width		-	panel layer width
         * @param {String} height		-	panel layer width
         * @param {String} initdisplay	-	panel layer DOM property style.display
         * @param {String} intMode		-	panel layer internal status mode name
         * @param {String} intxML		-	panel layer internal status html source
         * @param {String} atWhere		-	panel layer position: left, right, top, bottom(default)
         * @param {String} position		-	panel layer DOM property style.position: absolute(default)
         */
        build: function(mode, id, x, y, width, height, initdisplay, intMode, intxML, atWhere, position)
        {
            var p, pa = arguments[1];
			if (X.isVS(pa)) 
			{
				p = new PL(mode, id, x, y, width, height, atWhere, initdisplay, position);
			}
			else
			{
				p = new PL(mode, pa.id, pa.x, pa.y, pa.width, pa.height, pa.atWhere, pa.display, pa.position);
				intMode = pa.initname;
				intxML = pa.initHTML;
			}
            //
            if (intMode && intxML) 
            {
                p.load(intMode, intxML); // 有初始化界面
            }
            else 
            {
                p.build(mode); // 无初始化界面
            }
            
            return p;
        },
        /**
         * @param {String} uimode 界面状态标识
         * @return {Object} panel-dom object
         */
        get: function(uimode)
        {
            return wP.panels[uimode];
        },
        /**
         * 定时保持浮动定位
         */
        fly: function()
        {
            var arg = arguments[0];
            if (typeof arg == udn) 
            {
                if (arg > 0) 
                {
                    wP.timeI = arg; // 重新设置所有浮动容器定位间隔时间
                    wP.timeH = null;
                }
                else 
                {
                    X.rtc(wP.timeH);
                    wP.timeH = null;
                    return;
                }
            }
            else if (typeof arg == udb && arg) 
            {
				X.atc(wP.timeH);
                wP.timeH = null; // 重置所有浮动容器
            }
            /**
             * 定位浮动容器中的所有多边形
             */
            function fpos()
            {
                var ps = wP.panels, pg, doc, y, x, propname;
                for (propname in ps) 
                {
                    pg = ps[propname];
                    if (!X.isO(pg) || pg.mode != UI_WM_FLY) 
                    {
                        continue;
                    }
                    // 定位所有浮动多边形
                    
                    doc = X.body(), y = document.documentElement.scrollTop || doc.scrollTop, 
					x = document.documentElement.scrollLeft || doc.scrollLeft;
                    pg.moveTo(x, y);
                }
            }
            
            if (wP.timeH == null) 
            {
				// 模拟setInterval，节省CPU消耗
				//wP.timeH = X.rt(fpos, wP.timeI);
				function bt(){
					X.atc(wP.timeH);
					fpos.apply(this);
					wP.timeH = X.at(bt,wP.timeI);
				}
				wP.timeH = X.at(bt,wP.timeI);
            }
        }
    },    
	/**
     * 浮动多边形对象
     * @param {Object} sid	-	element id
     * @param {Object} sx	-	element's edge x
     * @param {Object} sy	-	element's edge y
     * @param {Object} w	-	element's width
     * @param {Object} h	-	element's height
     * @param {Object} sat	-	element's at where
     * @param {Object} d	-	element's initial display
     * @param {Object} spos	-	element's position style
     */
    PG = function(sid, sx, sy, w, h, sat, sd, spos)
    {        
		var _self = this,
		// 判断是否能够使用W3C style.position = 'fixed' 属性替代每秒钟检查并定位容器
		_useFix = X._useFix;
		
        /**
         * polygon matte for ie6-
         */
        function matte(pgon)
        {
            if (pgon && pgon._type_ == "polygon") 
            {
                var _melf = this;
                this.id = pgon.id + "_matte";
                this.build = function()
                {
                    if (!X.$(_melf.id)) 
                    {
                        var name = _melf.id;
                        frame = X.E(X.br.msie ? "<iframe name='" + name + "'></iframe>" : "iframe");
                        frame.id = name;
                        frame.setAttribute("frameborder", '0');
                        
                        if (X.msie6) 
                        {
                            frame[TAG_ATTRIBUTE_STYLE].filter = "progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0)";
                        }
                        frame[TAG_ATTRIBUTE_STYLE].backgroundColor = ("transparent");
                        frame[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_POSITION] = (STYLE_VALUE_ABSOLUTE);
                        frame[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_BORDER] = ("0");
                        frame[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = (pgon[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH]);
                        frame[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT] = (pgon[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT]);
                        frame[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_TOP] = (pgon[TAG_ATTRIBUTE_STYLE]['y'].toString() + STYLE_UNIT_PX);
                        frame[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_LEFT] = (pgon[TAG_ATTRIBUTE_STYLE]['x'].toString() + STYLE_UNIT_PX);
                        frame[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_ZINDEX] = (pgon[TAG_ATTRIBUTE_STYLE]['z-index'] - 1).toString();
                        
                        var body = X.body();
                        body.insertBefore(frame, body.firstChild);
                    }
                    return X.$(_melf.id);
                };
            }
        }
        /**
         * 动态加载modal界面元素
         * @param {Object} o current DOM Node
         * @param {Object} xl innerHTML
         */
        function insertHTML(node, xl)
        {
            if (node && xl) 
            {
                if (X.br.msie) 
                {
                    node[TAG_ATTRIBUTE_INNERHTML] = xl;
                }
                else 
                {
                    var pnode = node.parentNode;
                    pnode.removeChild(node);
                    node[TAG_ATTRIBUTE_INNERHTML] = xl;
                    pnode.insertBefore(node, pnode.firstChild);
                }
            }
        }
        
        this.at = sat ? sat : "bottom";
        this.pos = spos ? spos : STYLE_VALUE_ABSOLUTE;
        this.d = X.isVS(sd) ? sd : STYLE_VALUE_BLOCK;
        this._type_ = "polygon";
        this.id = sid; // id
        this.type = "polygon"; // panel or widget
        this.mode = UI_WM_FLY; // fly || static
        this.style = {
            'attach': this.at,// position - left, right, top, bottom
            'position': this.pos,
            'x': sx,// margin edge(left or right)
            'y': sy,// margin top
            'width': w,// runtime width - not used yet
            'height': h,// runtime height - not used yet
            'z-index': 2147483648,// runtime zIndex - not used yet
            'display': this.d
        };
        this['matte'] = null; // polygon matte object
        this.innerXml = {}
        /**
         * 获得当前polygon的蒙板instance
         *
         * @return 当前polygon的蒙板instance
         */
        this.buildMatte = function()
        {
            if (_self['matte'] == null) 
            {
                _self['matte'] = new matte(_self);
                _self['matte'].build();
            }
            return _self['matte'];
        };
        
        /**
         * 获得当前polygon的instance
         *
         * @return 当前polygon的instance
         */
        this.build = function()
        {
            if (!X.$(_self.id)) 
            {
                var div = X.E("div"), body = X.body();
                div.id = _self.id;
				div.className = 'wsdn_panels';
                if(Wi.WM != UI_WM_POP&&(Wc.ac(UI_PLACE)=="2"||Wc.ac(UI_PLACE)=="4"))
				{
					div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_RIGHT] = _self[TAG_ATTRIBUTE_STYLE]['x'].toString() + STYLE_UNIT_PX;
				}
				else
				{
					div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_LEFT] = _self[TAG_ATTRIBUTE_STYLE]['x'].toString() + STYLE_UNIT_PX;
				}
				
                div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_TOP] = _self[TAG_ATTRIBUTE_STYLE]['y'].toString() + STYLE_UNIT_PX;
                Wc.ac(UI_PLACE)=="100" ?  div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = "100%" :  div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = _self[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH];              
               
                div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT] = _self[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT];
                div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_POSITION] = _self[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_POSITION];
                div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_ZINDEX] = _self[TAG_ATTRIBUTE_STYLE]['z-index'].toString();
                div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = _self[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY];
				                
                body.insertBefore(div, body.firstChild);
                /**
                 * 一般只用于处理flash
                 *
                 * @description 只有IE版本小于6.0时才需要iframe蒙板
                 *              FireFox只能在原生网页中设置<embed/>的wmode属性为
                 *              transparent或opaque
                 */
                if (X.msie6 && X.contains(Wi.BF,'198.1')) // 通过Wi.BF判断是否需要对Bug#198.1进行修正
                {
                    _self.buildMatte();
                }
            }
            
            return _self;
        };
        /**
         * 定位当前polygon；如果蒙板存在则同步蒙板
         *
         * @param sx
         *        number, scroll left
         * @param sy
         *        number, scroll top
         * @return 成功返回true，失败返回false
         */
        this.MoveTo = function(sx, sy)
        {
            if (!X.$(_self.id)) 
            {
                return Fa;
            }
            var o = X.$(_self.id), 
			atWhere = _self[TAG_ATTRIBUTE_STYLE]['attach'].toLowerCase(), 
			atWs = [],
			bCW , 
			bCH, 
			CW = o.offsetWidth || o.clientWidth, 
			CH = o.offsetHeight || o.clientHeight, 
			rH,
			CA = ClientArea(),
			ys = EMPTY, xs = EMPTY;
			
			bCW = CA.w;
			bCH = CA.h;
			
            /*
             * 根据atWhere计算实际定位值
             */
            if (atWhere.indexOf('|') > -1) 
            {
                atWs = atWhere.split('|');
            }
            else 
            {
                atWs.push(atWhere);
            }
            for (var i = 0; i < atWs.length; i++) 
            {
                switch (atWs[i])
                {
                    case 'left':
                        xs = (sx + _self[TAG_ATTRIBUTE_STYLE]['x']).toString() + STYLE_UNIT_PX;
                        break;
                    case 'right':
                        xs = (bCW - CW - _self[TAG_ATTRIBUTE_STYLE]['x']);
                        if (X.quirks) 
                        {
                            xs -= 22;
                        }
                        xs = xs.toString() + STYLE_UNIT_PX;
                        break;
                    case 'top':
                        ys = (sy + _self[TAG_ATTRIBUTE_STYLE]['y']);      						            
                        ys = ys.toString() + STYLE_UNIT_PX;						
                        break;
                    case 'bottom':
						rH = bCH - CH - _self[TAG_ATTRIBUTE_STYLE]['y'];
                        ys = rH <= 0 ? (_self[TAG_ATTRIBUTE_STYLE]['y'] + sy) : (rH + sy);
						// 2009-03-31 commmented by gsyn77
						// if (X.msie7plus || !X.msie) 
                        // {
                        //     ys += 5;
                        // }   
                         // ys += 3;
                        ys = ys.toString() + STYLE_UNIT_PX;  
                        break;
                    case 'center':
						// modified in 2009-03-16 by gsyn77 - center方式也受偏移量影响
                        xs = X.isES(xs) ? (_self[TAG_ATTRIBUTE_STYLE]['x'] + sx + (bCW - CW) / 2).toString() + STYLE_UNIT_PX : xs;
                        ys = X.isES(ys) ? (_self[TAG_ATTRIBUTE_STYLE]['y'] + sy + (bCH - CH) / 2).toString() + STYLE_UNIT_PX : ys;
                        break;
                    case 'random': // Drag & Drop 
	                    /**
						 * BUGFIXES #222 - 火狐下拖动后再最小化停留位置出现问题
						 * 修正 - 只能上下拖曳
						 */
                        xs = X.isES(xs) ? (_self[TAG_ATTRIBUTE_STYLE]['x'] + sx).toString() + STYLE_UNIT_PX : xs;
                        ys = X.isES(ys) ? (_self[TAG_ATTRIBUTE_STYLE]['y'] + sy).toString() + STYLE_UNIT_PX : ys;
                        break;
                    default: // 默认在右下角显示
                        xs = (bCW - CW - _self[TAG_ATTRIBUTE_STYLE]['x'] + sx).toString() + STYLE_UNIT_PX;
                        ys = (bCH - CH - _self[TAG_ATTRIBUTE_STYLE]['y'] + sy).toString() + STYLE_UNIT_PX;
                        break;
                }
            }
            
            o[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_TOP] = ys;
            o[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_LEFT] = xs;
            o[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_POSITION] = STYLE_VALUE_ABSOLUTE;

            var ma = _self['matte'];
            if (X.isO(ma)) 
            {
                var mo = X.$(ma.id);
                if (mo) 
                {
                    mo[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_TOP] = ys;
                    mo[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_LEFT] = xs;
                    mo[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_BLOCK;
                    mo[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_POSITION] = STYLE_VALUE_ABSOLUTE;
                    
                    /*
                     * 根据polygon的runtime width、height 设定蒙板的width、height
                     */
                    if (this[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] == STYLE_VALUE_AUTO) 
                    {
                        if (CW > 0) 
                        {
                            mo[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = CW.toString() + STYLE_UNIT_PX;
                        }
                    }
                    if (this[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT] == STYLE_VALUE_AUTO) 
                    {
                        if (CH > 0) 
                        {
                            mo[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT] = CH.toString() + STYLE_UNIT_PX;
                        }
                    }
                }
            }
            
            return Tr;
        };
        /**
         * 使用 position = 'fixed' 定位容器
         * @param {Object} sx
         * @param {Object} sy
         */
        this.moveTo = function(sx, sy, reset)
        {
            if (!X.$(_self.id)) 
            {
                return Fa;
            }
			// 如果不能使用W3C position='fixed'属性，则转换到兼容性视图下的MoveTo()			
            if(!_useFix)
			{
				return this.MoveTo(sx,sy);				
			}
			
            var o = X.$(_self.id), 
			atWhere = _self[TAG_ATTRIBUTE_STYLE]['attach'].toLowerCase(), 
			atWs = [], bCW, bCH, 
			CW = o.offsetWidth || o.clientWidth, 
			CH = o.offsetHeight || o.clientHeight, 
			rH, 
			CA = ClientArea(), 
			ys = EMPTY, xs = EMPTY, 
			xV = EMPTY, yV = EMPTY;
            
            bCW = CA.w;
            bCH = CA.h;
            
            /*
             * 根据atWhere计算实际定位值
             */
            if (atWhere.indexOf('|') > -1) 
            {
                atWs = atWhere.split('|');
            }
            else 
            {
                atWs.push(atWhere);
            }
            for (var i = 0; i < atWs.length; i++) 
            {
                switch (atWs[i])
                {
                    case 'left':
                    case 'right':
                        xV = atWs[i];
                        xs = _self[TAG_ATTRIBUTE_STYLE]['x'].toString() + STYLE_UNIT_PX;
                        break;
                    case 'top':
                    case 'bottom':
                        yV = atWs[i];
                        ys = _self[TAG_ATTRIBUTE_STYLE]['y'].toString() + STYLE_UNIT_PX;
                        break;
                    case 'center':
                        // modified in 2009-03-16 by gsyn77 - center方式也受偏移量影响                    
                        if (X.isES(xs)) {
                            xV = 'left';
                            xs = (_self[TAG_ATTRIBUTE_STYLE]['x'] + (bCW - CW) / 2).toString() + STYLE_UNIT_PX;
                        }
                        if (X.isES(ys)) {
                            yV = 'top';
                            ys = (_self[TAG_ATTRIBUTE_STYLE]['y'] + (bCH - CH) / 2).toString() + STYLE_UNIT_PX;
                        }
                        break;
                    case 'random': // Drag & Drop 
                        /**
	                     * BUGFIXES #222 - 火狐下拖动后再最小化停留位置出现问题
	                     * 修正 - 只能上下拖曳
	                     */
                        if (X.isES(xs)) {
                            xV = 'left';
                            xs = (_self[TAG_ATTRIBUTE_STYLE]['x'] ).toString() + STYLE_UNIT_PX;
                        }
                        if (X.isES(ys)) {
                            yV = 'top';
                            ys = (_self[TAG_ATTRIBUTE_STYLE]['y'] ).toString() + STYLE_UNIT_PX;
                        }
                        break;
                    default: // 默认在右下角显示
                        yV = 'bottom';
                        ys = _self[TAG_ATTRIBUTE_STYLE]['y'].toString() + STYLE_UNIT_PX;
                        
                        xV = 'right';
                        xs = _self[TAG_ATTRIBUTE_STYLE]['x'].toString() + STYLE_UNIT_PX;
                        break;
                }
            }
			/*
			 * 首先清除'left'、'top'
			 */
            o[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_TOP] = '';
			o[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_LEFT] = '';
			o[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_BOTTOM] = '';
			o[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_RIGHT] = '';
			//o[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_POSITION] = 'static';
			
            o[TAG_ATTRIBUTE_STYLE][yV] = ys;
            o[TAG_ATTRIBUTE_STYLE][xV] = xs;
			
			// firefox || opera || ( ie7+ && !quirks
			o[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_POSITION] = 'fixed';
            return Tr;
        };
        /**
         * 从指定url加载网页内容——必须来源于同一个域名
         * 2009-03-02 modified by gsyn77 v1.40
         * 	- 将UI模板加载方式改为js，不使用原来的iframe+html，以解决傲游等浏览器的兼容性问题
         * @param name 加载的界面内容source的名称
         * @param url 加载的界面内容source的来源地址url
         * @param callback 加载界面内容source完成之后需要执行的动作
         *
         * @return polygon instance dom object
         */
        this.T = function(name, url, callback)
        {
            // 如果当前polygon没有构建，那么构建之
            var o = X.$(_self.id), a = arguments;
            if (!X.isO(o)) 
            {
                _self.build();
            }
			/**
			 * 内部方法，用于在wnframe完成加载后执行动作
			 * @param {Object} xhtml
			 */
            function innerXml(xhtml)
            {
                var chtml = X.clean(xhtml); // 清理所有脚本
                chtml = chtml.replace(/\%7B/gi, "{").replace(/\%7D/gi, "}").replace(/\$\{[.\w]+\}/gi, W.CVar);
                _self.load(name, chtml, callback);
            }
			/**
			 * 内部方法，用于在script完成加载后执行动作
			 * @param {Object} exJs
			 */
			function innerJS(exJs)
			{
				if(Ui.TU)
				{
					var chtml = UEC(Ui.TU).replace(/\$\{[.\w]+\}/gi, W.CVar);
                	_self.load(name, chtml, callback);
				}
			}
            // 检查是否是读取并重置innerHTML操作
            if (a.length == 1 && X.isS(a[0])) 
            {
                return _self.load(name);
            }
            else 
            {
				/*
				 * 2009-03-02 commented by gsyn77 v1.40 - 使用UI脚本而不是之前的iframe+html
				 */
                // var wnframe = new wNF();
                // wnframe.T(name + X.ticks().toString(), url, innerXml);
				
				// 2009-03-02 commented by gsyn77 v1.40 
				//	- 使用UI脚本而不是之前的iframe+html
                // xhrp.xript(url,'',innerJS);
				
				/*
				 * 2009-04-23 modified by gsyn77
				 *  - 如果已经静态化UI脚本，则直接加载之；否则，load
				 */
				if(Ui.TU)
				{
					innerJS();
				}
				else
				{
					xhrp.xript(url,'',innerJS);
				}
            }
            
            return o;
        };
        
        /**
         * 卸载Dom对象并缓存其HTML source
         * @param {Object} name
         */
        this.sink = function(name)
        {
            var node = X.$(_self.id);
            _self.innerXml[name] = node[TAG_ATTRIBUTE_INNERHTML];
            if (X.br.msie) 
            {
                node[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
            }
            else 
            {
                node[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
            }
            node[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
        };
        /**
         * 加载polygon界面的HTML source并设置为innerHTML的值
         *
         * @param {String} name
         * @param {String} hml
         * @param {Function} callback - 不带任何参数的Fucntion
         *
         * @return {DOMObject} polygon dom instance
         */
        this.load = function(name, hml, callback)
        {
            var arg = arguments, isize = arg.length, o = X.$(_self.id), xtml;
            if (!X.isO(o)) 
            {
                _self.build();
				o = X.$(_self.id);
            }
            
            if ((isize == 1 && X.isS(arg[0])) || !X.isO(arg[1])) // name
            {
                xtml = _self.innerXml[name];
                if (X.isS(xtml)) 
                {
                    insertHTML(o, xtml);
                }
            }
            else if (isize == 2) // 如果只有两个参数，需要判断是string还是function
            {
                if (X.isS(arg[1])) // hml
                {
                    _self.innerXml[arg[0]] = arg[1];
                    insertHTML(o, arg[1]);
                }
                
                if (X.isF(arg[1])) // callback
                {
                    xtml = _self.innerXml[arg[0]];
                    if (X.isS(xtml)) 
                    {
                        insertHTML(o, xtml);
                    }
                    arg[1].call(this);
                }
            }
            else if (isize == 3) 
            {
                _self.innerXml[arg[0]] = arg[1];
                insertHTML(o, arg[1]);
                if (X.isF(arg[2])) 
                {
                    arg[2].call(this);
                }
            }
            
            X.$(_self.id)[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_BLOCK;
            
            return X.$(_self.id);
        };
    },   //
     /**
     * 浮动Panel对象
     *
     * @param {Object} modal - panel 对应的ui modal：request, min, normal, max, popwin
     * @param {Object} sid
     * @param {Object} sx
     * @param {Object} sy
     * @param {Object} w
     * @param {Object} h
     * @param {Object} d
     * @param {Object} sat
     * @param {Object} spos
     */
    PL = function(modal, sid, sx, sy, w, h, d, sat)
    {
        var b = new PG(sid, sx, sy, w, h, d, sat);
        b.type = "panel";
		b.modal = modal; // panel 对应的ui modal：request, min, normal, max, popwin
        return b;
    };
    
    
    /**
     * 应用场景下的公开方法
     *
     * @namespace W.ui
     */
    Wi.TG = wP.TG;
    Wi.choose = wP.get;
    Wi.spot = wP.current;
    Wi.dragdrop = wP.drag;
    Wi.current = function()
    {
        return wP.currentModal;
    }
    Wi.WP = wP.panels;
	Wi.build = wP.build;
    
    /*********************STAGE 6：建立client-server消息槽框架**********************
     * @namespace W.XP, W.core.slots
     * @overview
     *  通信协议 v0.1
     *  信号槽 v0.5
     **************************************************************************/
    
    XP.M = {};
	/**
	 * 用于处理服务器发来的命令字
	 * @param {Object} stana
	 */
    XP.M.A = function(stana)
    {
        if (!X.isO(stana)) 
        {
            return; // 非法数据格式
        }
        /*
         * 检查 XP subset 数据包命名空间（_ns_）以区别类型处理
         */
        switch (X.trim(stana._ns_))
        {
            /*
             * server 发来的消息 -
             * from: eid@[customer.domain]/web || eid@[customer.domain]/xms
             * 'tag': 'active', 'composing', 'paused', 'inactive', 'gone'
             */
            case 'message':
            {
                switch (X.trim(stana.type))
                {
                    case 'chat':
                        // 调用Wsdn.user.ui.slots中定义的‘信号槽’
                        W.UT('show', 'msg', stana);
                        break;
                    case 'headline': // 『保留』暂时使用 state == undefined 来判断是否是‘公告消息’或‘初始消息’
                        // 调用Wsdn.user.ui.slots中定义的‘信号槽’
                        W.UT('show', 'headline', stana);
                        break;
                    case 'normal':
                        break;
                }
                break;
            }
            /*
             * 暂时只处理server发来的消息 - type = 'result'
             * 暂时不做iq的type=result时的id检查
             */
            case 'iq':
            {
                switch (X.trim(stana.type))
                {
                    case 'result':
                        switch (X.trim(stana.query))
                        {
                            case 'init':
                            {
                                U['IPr'](stana);
                                break;
                            }
							case 'livefx': // 2009-05-14 by gsyn77 - #149
							{
								W.Fxso(stana); // 負責將發來的Cookie存儲到FSO中
								break;
							}
                            case 'hold':
                            {
                                W.T('poll', 'hold', stana.store);
                                break;
                            }
                            case 'chat':
                            {
                                // 启动短信对话流程
                                if (stana.from && (/(.*)\/sms/gi.test(stana.from) || X.contains(stana.from,'/sms')))
                                {
                                    B.BC(PROPERTY_VALUE_USERSTATE_CX);
									// 提示启动短信对话流程
									W.UT('show', 'xms', stana);
                                }
                                else // 启动在线对话流程
                                 {
                                    B.BC(PROPERTY_VALUE_USERSTATE_C);
									W.UT('show', 'msg', stana); // 2009-03-21 added by gsyn77 - 提示对话接通
                                }
                                break;
                            }
							case 'invite':
							{
								/*
								 * BUGFIXED: 
								 * 	firefox 3+ 执行 regex 判断时会出现Bug - 如第一次执行为true，第二次为false
								 * 使用indexOf进行补充判断以解决 FireFox 3+ regex 执行 Bug
								 */
								// 如果收到后台主动对话邀请，直接开始对话流程
								if (/(.*)\/txt/gi.test(stana.from) || X.contains(stana.from,'/txt'))
								{															
									Wc.cu(PROPERTY_VALUE_USERSTATE_C);									

								}
								else if (/(.*)\/sms/gi.test(stana.from) || X.contains(stana.from,'/sms'))
								{
									
									Wc.cu(PROPERTY_VALUE_USERSTATE_CX);									
									
								}
								else if (/(.*)\/robot/gi.test(stana.from) || X.contains(stana.from,'/robot'))
								{
									B[PROPERTY_AUTOPOP_MSG]=B[PROPERTY_GREETINGS];
									Wi.Fp();
									W.UT('show', 'msg', stana); // 2009-10-30 added by 罗标新 弹出窗口自动邀请
									
								}
								break;
							}
                            default:
                            {
                                // 调用Wsdn.user.ui.slots中定义的‘信号槽’
                                W.UT('show', stana.query, stana);
                                break;
                            }
                        }
                        break;
                }
                break;
            }
        }
    };
    /**
     * ‘get’信号槽 - client poll：‘数据获取’类型请求
     * @param {Object} action
     * @param {Object} data
     */
    XP.M.O = function(action, data)
    {
        switch (action)
        {
            case 'touch':
            {
                B.T(data);
                break;
            }
            case 'hold':
            {
                B.K(data);
                break;
            }
			/**
			 * BUGFIXES #221: 加固算法 - 改为Browser端在第一次touch时启动
			 */
            case 'guard':
            {
                B.G(data);
                break;
            }
            case 'list':
            {
                B.LI(data);
                break;
            }
        }
    };
    /**
     * ‘set’ 信号槽 - client push：‘数据提交’类型请求
     * @param {Object} action	-	动作名称
     * @param {Object} data		-	相关数据
     */
    XP.M.U = function(action, data)
    {
        switch (action)
        {
            case 'note':
            {
                B.N(data);
                break;
            }
            case 'contact':
            {
                B.CTC(data);
                break;
            }
            case 'chat':
            {
                B.CT(data);
                break;
            }
			case '_fxu_': // 2009-05-21 by gsyn77 - #242 文件上傳
			{
				B.Fu(data);
				break;
			}
        }
    };
    /**
     * 注册‘result’信号槽 - server 响应之前get、set请求结果
     * server 响应的结果目前只有 message、iq 两种类型
     * 其中：
     * 	message 负责对话、公告消息内容、backendant state（eg. composing, gone）
     * 	iq 负责各种 request 的响应动作（response）
     */
    ES.B('result', XP.M.A);
    /**
     * 注册‘get’信号槽 - client poll：‘数据获取’类型请求
     * 这些请求包括：
     * 	touch	-	<iq type='set' query='touch'/> visitor进入新页面（包括：弹出对话窗口）或首次进入网站
     * 	hold	-	<iq type='set' query='hold'/> 保持isitor在线状态，并返回各种backend需要发给front-end的信息——交由Wsdn.B('result')处理
     * 	guard	-	<iq type='set' query='guard'/> 『暂时未实现』
     * 	list	-	<iq type='set' query='guard'/> 『未确定是否需要此iq请求』
     */
    ES.B('poll', XP.M.O);
    /**
     * 注册‘set’信号槽 - client ‘数据提交’类型请求
     * 这些请求包括：
     * 	contact - 	<iq type='set' query='contact'/>
     * 	call	-	<iq type='set' query='call'/>
     * 	chat	-	<message state='composing'/> 或者 <message body='...'/> 开始对话或发送visitor输入的对话内容
     */
    ES.B('push', XP.M.U);
    
    /**其他内部事件**/
    ES.B('cancel', B.CA);
    
    /******************************STAGE 7：需要初始化的参数********************************/
    Wi.WM = UI_WM_FLY; // 初始化webpart显示模式为“浮动定位”
    Wi.BF = '';	// 用于控制浏览器兼容性问题
    	
    Wi.UF =UI_USE_FLASH; //初始化邀请显示模式为 flash
    
    Wc.ac(PROPERTY_SERVICE_PORT_URL_ROOT, SERVICE_PORT_URI); 
    /**
     * 将Wsdn中的参数变量替换为其值
     * @param {Object} str
     */
    W.CVar = function(str)
    {
        return new Function('return ' + ((str.indexOf('$') == 0) ? (str.substr(2, str.length - 3)) : str))();
    };
    
    W.C = B.CL;
	
    /********************************* #279 ***********************************
     * #279 - 锁定当前focus窗口作为对话窗口（弹出窗口例外）
     *  - 不使用FlashCookie的原因在於：Firefox似乎對每個流覽器窗口中的相同Flash做了各自
     *    的緩存，導致相互之間無法同步數據
     *************************************************************************/
    function wcookie(name, value){
        if (name && value) // 写入
        {                        
			/*
            // 写入FlashCookie中
            if (W.Fx && W.Fx()) {
                W.Fxsc([name, value].join('|'));
            }
            else if (X.CookieEnabled) // 写入浏览器Cookie中
            {
                if (X.msie) {
                    var d = new Date();
                    d.setTime(d.getTime() + (5 * 60 * 1000)); // 5 分鐘後過期
                    window.document.cookie = [name, '=', value, '; expires=', d.toGMTString(), '; path=/'].join('');
                }
                else {
                    window.document.cookie = [name, '=', value, '; expires=Session', '; path=/'].join('');
                }
            }
            */
            if (X.CookieEnabled) { // 从浏览器Cookie中读取
                if (X.msie) {
                    var d = new Date();
                    d.setTime(d.getTime() + (2 * 60 * 60 * 1000)); // 2小時後過期
                    window.document.cookie = [name, '=', value, '; expires=', d.toGMTString(), '; path=/'].join('');
                }
                else {
                    window.document.cookie = [name, '=', value, '; expires=Session', '; path=/'].join('');
                }
            }
        }
        else if (name) // 读取
        {        
			/*                
            // 从FlashCookie中读取
            if (W.Fx && W.Fx()) {
                W.Fxrc(name);
                return Wc.ac(name);
            }
            else if (X.CookieEnabled) { // 从浏览器Cookie中读取
                var key = [name, '='].join(''), i0, i1, cc = window.document.cookie;
                if (cc.length && (-1 != (i0 = cc.indexOf(key)))) {
                    if (-1 == (i1 = cc.indexOf(";", i0 + key.length))) i1 = cc.length;
                    return (cc.substring(i0 + key.length, i1));
                }
            }
            */
            if (X.CookieEnabled) { // 从浏览器Cookie中读取
                var key = [name, '='].join(''), i0, i1, cc = window.document.cookie;
                if (cc.length && (-1 != (i0 = cc.indexOf(key)))) {
                    if (-1 == (i1 = cc.indexOf(";", i0 + key.length))) i1 = cc.length;
                    return (cc.substring(i0 + key.length, i1));
                }
            }
        }
    }
    Wi.winame = '_wsdn_bwin_';
    Wi.winid = [X.ticks()].join('');
	/**
	 * #279 - 锁定当前focus窗口作为对话窗口（弹出窗口例外）
	 */
    Wi.lockat = function(){        
        var a = arguments;
        if (a.length == 2) {
            wcookie(a[0], a[1]);
            return true;
        }
        if (a.length == 1) {
            return wcookie(a[0]);
        }
        
        return false;
    };
    /**
     * 註冊流覽器事件監聽器
     * @param {Object} n
     * @param {Object} fn
     */
    W.WEvent = function(n, fn){
        if (X.msie) {
            window.attachEvent(['on', n].join(''), fn);
        }
        else {
            window.addEventListener(n, fn, true);
        }
    }
    /**
     * 负责加载界面并连通system
     */
    W.BT = function(){
        try {
            if (window.name.toLowerCase() == 'wsdn_name') {
                return;
            }
        } 
        catch (e) {
        }
        
        B[PROPERTY_DOCUMNET_TITLE] = document.title;
                
        /**
         * #279 - 針對1個彈出對話窗口~多個流覽頁面情況
         * 2009-07-10 by gsyn77
         */
        if (Wi.WM == UI_WM_POP) {
            W.Fxcwid(Wi.winid); // 將當前彈出窗口id保存到FlashCookie中
        }
        /**
         * #279 - 當打開新窗口（包括後臺打開）時，以新窗口為主進行登記
         */
		Wi.lockat(Wi.winame, Wi.winid);
        /**
         * #264 - 网眼前端有新消息要闪烁当页标题
         */			
        W.WEvent('focus', function(){ 
			/**
	         * #279 - 當流覽器窗體獲得focus時，鎖定當前對話窗體
	         */
	        Wi.lockat(Wi.winame, Wi.winid);
			EndBlinkDocumentTitle();
		});
        W.WEvent('blur',function(){
			StartBlinkDocumentTitle();
		});
        X.rt(B.PM,3000);
        
		/**
         * 首先加载界面，然后提交touch请求 2009-04-24 modified by gsyn77
         */
        W.T('poll', 'touch');
    };
	
	/**
	 * refs #287 - 用于在浏览器DomContentLoaded事件时执行事先设定的任务
	 *   2009-07-06 by gsyn77
	 */
	W.after = function(){
        function executeTaskList(){
            var fn = null;
            for (; (fn = TASKLIST_AFTER_DOMCONTENT_LOAD.pop());) {
                if (X.isF(fn)) fn.apply(this);
            }
        }
		if (X.isO(TASKLIST_AFTER_DOMCONTENT_LOAD) && TASKLIST_AFTER_DOMCONTENT_LOAD.length > 0) {
            /**
             * Using the 'doScroll' codes instead of window.onload event trigger. <2009-07-06 by gsyn77>
             *  ------------------------------------------------------
             *   window.attachEvent('onload', function(){
             *   	var fn = null;
             *   	for (; (fn = TASKLIST_AFTER_DOMCONTENT_LOAD.pop());) {
             *   		if (X.isF(fn)) fn.apply(this);
             *   	}
             *   });
             *  ------------------------------------------------------
             * Thanks for Hedger Wang' article (http://www.hedgerwow.com/360/dhtml/ie-dom-ondocumentready.html).
             *
             * Kudos to Hedger Wang, Dean Edwards, Diego Perini and all the other amazing developers who keep us moving forward.
             */
            (function(){
                //check IE's proprietary DOM members 
                if (!document.uniqueID && document.expando) {
					//you can create any tagName, even customTag like <document:ready />  
					var tempNode = document.createElement('wsdn:ready');
					(function(){
						try {
							//wait until document.readyState === 'complete'; 
							if (document.readyState != 'complete') return X.at(arguments.callee, 0);
							
							//see if it throws errors until after ondocumentready 
							tempNode.doScroll('left');
							
							//call my function which catch window.onDocumentReady, 
							//e.g. alert('window.onDocumentReady()');
							executeTaskList();
							
							//relaese some memory, if possible 
							tempNode = null;
						} 
						catch (err) {
							X.at(arguments.callee, 100);
						}
					})();
				}
				else
				{
					executeTaskList();
				}
            })();
        }
	};
	
    /*************************STAGE 8： Begin Bootstrap**************************/
	/*
     * 判断是否有参数传递过来
     */
    (function()
    {
        var wsid = X.$("Xsdn_tracker"), arr, size, i, pa, nv, n, v, src, idx, param;
		function processParams()
		{
			if (pa.indexOf('=') > -1) 
            {
                nv = pa.split('='), n = nv[0], v = nv[1];
                
                switch (n.toLowerCase())
                {
                	case 'icon':
                		Wc.ac(PROPERTY_ICON,v); //固定连接
                	    break;
					case 'ins':
						Wi.ins = v; // 用于指定其安装位置，目前只使用'middle'来说明其<script/>代码安装在<body>中的任意位置并且使用document.write()
						break;
					case 'pid':
						if (v && X.isVS(v) && v!= 'null')
						W.pid = v; // 合作伙伴id
						break;
                    case 'wm': // 设置当前页面中webpart显示模式 - fly || static || popwin
                        Wi.WM = v;
                        Wc.ac(PROPERTY_WM,v);	 //弹出窗口       
                        break;
                    case 'uf': //设置当前自动邀请是否使用 flash 0: 不使用 ; 1: 使用
                        Wi.UF=v;
                        break;
                    case PROPERTY_USER_STATE: // 设置用户初始状态
                        Wc.ac(PROPERTY_USER_STATE, v);
                        break;
                    case 'st': // 设置界面类型
                        Wc.ac(PROPERTY_UI_STYLE_CURRENT, v);
                        break;
					case 'w': // 客户站点id
						Wc.ac(PROPERTY_WSID,v);
						break;
					case 's': // 访客唯一标识id
						Wc.ac(PROPERTY_SID,v);
						break;
					case 'ty': // 指定弹出窗口类型: call - 电话，chat - 对话，note - 留言
						Wc.ac('pop-type',v);
						break;
					case PROPERTY_EID: // 指定对话EmployeeId
						Wc.ac(PROPERTY_EID,v);
						break;
					case PROPERTY_EMPLOYEE_STATE: // 指定对话EmployeeId的当前在线状态：1 - 在线，0 - 离线
						Wc.ac(PROPERTY_EMPLOYEE_STATE,v);
						break;
					case PROPERTY_EMPLOYEE_ADDONSERVICE: // 指定对话EmployeeId的增值服务状态：> 0 开通(=2)，0 - 未开通
						Wc.ac(PROPERTY_EMPLOYEE_ADDONSERVICE,v);
						break;
					case '_bfn':	// bug fix no，用于控制浏览器兼容性问题——逗号分隔的bugNo列表字符串
						/*
						 * 已知浏览器兼容性问题包括：
						 * #198-1 - 输入框（input、textarea）、iframe、object会出现在浮动div上部——可以通过加入『透明iframe背景遮盖』解决这一问题；
						 * #198-2 - 计算机配置较低（特别是内存<=256MB）时，如果使用『透明iframe背景遮盖』则在中文输入时会导致浏览器内容闪烁；显示后台消息时也会出现同样问题；
						 * 
						 * 默认不使用iframe遮板
						 */
						Wi.BF = v;
						break;
                }
            }
		}
        if (wsid && wsid.nodeName.toLowerCase() == "script") 
        {
            src = X.trim(wsid.src);
            idx = src.indexOf('?');
            param = X.trim(wsid.src).substring(idx + 1);
			// 测试是否直接只用客户站点id作为Js脚本文件名
            wsid = EMPTY;
			wsid = /\/(\d+)\.js/gi.exec(src)[1]; // 通过正则式得到客户站点id
            if (param.indexOf(STRING_CONNECTOR) > -1) // like trackers?1234&WM=fly&US=C
            {
                arr = param.split(STRING_CONNECTOR), size = arr.length;
				if (!X.isVS(wsid)) 
				{
					wsid = arr[0]; // first param must be wsid
				}
                for (i = 0; i < size; i++) 
                {
                    pa = arr[i];
                    processParams();
                }
                
            }
            else 
            {
				if (!X.isVS(wsid)) 
				{
					wsid = param; // like trackers?1234				
				}
				else
				{
					pa = param;
					processParams();
				}
            }
            if(wsid != "0000")
            {
               Wc.ac(PROPERTY_WSID, wsid);
            }
        }
    })();
		
//})();

	
	//(function()
//{	
	/**************************************************************************
	 * @overview 左右+居中(+列表)
	 * @author gsyn77
	 * @version 1.60
	 * @history
	 * 	2009-05-20 created by gsyn77
	 *************************************************************************/
		
	
	
    /********************* 基本配置信息 ****************************/
    var UEC = unescape, //
	EMPTY = '', //
	
	/**
	 * INCLUDE: 引入不同语言文字配置Js脚本
	 */
	LANG_TIPSTITLE = '%u6E29%u99A8%u63D0%u793A', // 温馨提示
LANG_SWITCHCALL = '%u901A%u8BDD%u8F6C%u63A5%u4E2D%uFF0C%u8BF7%u7A0D%u5019%u2026%u2026', // 通话转接中，请稍候……	
LANG_NOTEHASENT = '%u60A8%u7684%u7559%u8A00%u5DF2%u7ECF%u53D1%u9001.',	// 您的留言已经发送.
LANG_CONTACTSENT = '%u6D88%u606F%u5DF2%u7ECF%u63D0%u4EA4', // 消息已经提交
LANG_NOTE_SUCCESS = "%u7559%u8A00%u53D1%u9001%u6210%u529F%uFF01", // 留言发送成功！
LANG_NOTE_FAILURE = "%u7559%u8A00%u53D1%u9001%u5931%u8D25%uFF01", // 留言发送失败！
LANG_CHAT_HISTORY = '%u5BF9%u8BDD%u5386%u53F2%u5982%u4E0B', // 对话历史如下
LANG_PRESENCE_COMPOSING = "%u5BF9%u65B9%u6B63%u5728%u8F93%u5165%u6587%u5B57%u2026%u2026", // 对方正在输入文字……
LANG_PRESENCE_GONE = '', // 对方已经退出对话  modify by luobx  不在提示后台退出 %u5BF9%u65B9%u5DF2%u7ECF%u9000%u51FA%u5BF9%u8BDD%u3002
LANG_PHONE_ERROR = '%u8F93%u5165%u7684%u7535%u8BDD%u53F7%u7801%u4E0D%u6B63%u786E%uFF0C%u8BF7%u91CD%u65B0%u8F93%u5165%uFF01', //
LANG_VALIDCODE_ERROR = '%u8BF7%u8F93%u5165%u9A8C%u8BC1%u7801%uFF01', //
LANG_PHONE_ERROR_TIPS = "%u6E29%u99A8%u63D0%u793A%uFF1A%u7535%u8BDD%u53F7%u7801%u4E0D%u6B63%u786E%uFF0C%u6B63%u786E%u53F7%u7801%u8F93%u5165%u5982%uFF1A02083586353%u621601087653201-8011", //
LANG_EMAIL_ERROR_TIPS = "%u6E29%u99A8%u63D0%u793A%uFF1A%u90AE%u7BB1%u8F93%u5165%u4E0D%u6B63%u786E%uFF0C%u6B63%u786E%u90AE%u7BB1%u8F93%u5165%u5982%uFF1Asupport@webeye.net.cn", //
LANG_CORP_TIPS = '%u6E29%u99A8%u63D0%u793A%uFF1A%u516C%u53F8%u3001%u59D3%u540D%u81F3%u5C11%u9700%u586B%u5199%u4E00%u9879%u3002', //
LANG_PHONE_TIPS = '%u6E29%u99A8%u63D0%u793A%uFF1A%u7535%u8BDD%u3001%u90AE%u7BB1%u81F3%u5C11%u9700%u586B%u5199%u4E00%u9879%u3002', //

LANG_VISITOR_AT = "%u8BBF%u5BA2%u5728", //
LANG_CONTACT_AT = "%u586B%u5199%u8054%u7CFB%u65B9%u5F0F%u5982%u4E0B%uFF1A", //
LANG_TITLE_CORP = "%u516C%u53F8%uFF1A",
LANG_TITLE_NAME = "%u59D3%u540D%uFF1A",
LANG_TITLE_PHONE = "%u7535%u8BDD%uFF1A", 
LANG_TITLE_WEBSITE = "%u7F51%u5740%uFF1A",
LANG_TITLE_EMAIL = "%u90AE%u7BB1%uFF1A",
LANG_TITLE_IM = "IM%uFF1A",
LANG_INPUT_EMPTY_ERROR = '%u6E29%u99A8%u63D0%u793A%uFF1A%u53D1%u9001%u6D88%u606F%u5185%u5BB9%u4E0D%u5F97%u4E3A%u7A7A%u3002',
LANG_SAID = '%u8BF4%uFF1A',	
LANG_SEND_EMAIL = '%u53D1%u9001%u90AE%u4EF6%u5230%uFF1A',
LANG_SEND_CALL = '%u62E8%u6253%u7535%u8BDD%uFF1A',
LANG_TRADEMARK = '%u7F51%u773C%26trade%3B', // 网眼&trade;
LANG_COPYRIGHTS = '%26copy%3B%26nbsp%3B' + X.Year(), // &copy;&nbsp;2009
LANG_ICON_TIP_TEL = '%u62E8%u6253%u5BF9%u65B9%u514D%u8D39%u7535%u8BDD',
LANG_ICON_TIP_CHAT = '%u4E0E%u5BF9%u65B9%u5728%u7EBF%u6D3D%u8C08',
LANG_ICON_TIP_XMS = '%u4E0E%u5BF9%u65B9%u8FDB%u884C%u77ED%u4FE1%u6D3D%u8C08',
LANG_ICON_TOP_NOTE = '%u7ED9%u5BF9%u65B9%u7559%u8A00',
LANG_POPW_REFUSED = '%u5F39%u51FA%u7A97%u53E3%u88AB%u62E6%u622A%uFF0C%u8BF7%u5173%u95ED%u5F39%u51FA%u7A97%u53E3%u62E6%u622A%u9009%u9879', //提示弹出窗口被拦截
/* 文件上传部分提示文字 */
LANG_LIVEFU_FILE = '%u6587%u4EF6', // 文件
LANG_LIVEFU_TRANSFORCOMPLETE = '%20%u4E0A%u4F20%u5B8C%u6BD5%uFF01', // 上传完毕！
LANG_ERROR_FILESIZE = '%u4E0A%u4F20%u6587%u4EF6%u5927%u5C0F%u9650%u5236%u4E3A%uFF1A', // 上传文件大小限制为：
LANG_ERROR_NOCHAT_NOUPLOAD = '%u53EA%u6709%u5BF9%u8BDD%u4E2D%u624D%u80FD%u4E0A%u4F20%u6587%u4EF6%uFF01', // 只有对话中才能上传文件！
LANG_ERROR_OPENFILEDIALOG = '%u4E0D%u80FD%u6253%u5F00%u6587%u4EF6%u4E0A%u4F20%u5BF9%u8BDD%u6846%uFF01', // 不能打开文件上传对话框！
LANG_ERROR_OPENFILE = '%u6253%u5F00%u4E0A%u4F20%u6587%u4EF6%u51FA%u9519%uFF01', // 打开上传文件出错！
LANG_ERROR_HTTP='%u7F51%u7EDC%u8FDE%u63A5%u51FA%u73B0%u9519%u8BEF%uFF01', // 网络连接出现错误！
LANG_ERROR_NOUPLOAD_AUTHORITY = '%u6CA1%u6709%u6587%u4EF6%u4E0A%u4F20%u6743%u9650%uFF01' ,// 没有文件上传权限！

	
	/**
	 * UI参数
	 */
	UI_ATWHERE = 0, // 用于区分左右（0）、上下（1）、图标嵌入链接（2）
	UI_KIND = '_ui_kind',
	UI_STYLE = '_ui_style',
	UI_PLACE = '_ui_place',
	UI_POSITION = '_ui_posi',
	UI_POSITION_DEFAULT = 'bottom|right',
	UI_POSITIONS = ['bottom|center','left|center','right|center','right|bottom','left|bottom','top|center'],
	UI_WM_POPWIN = 'popwin',
	UI_WM_FLY = 'fly',
	UI_WM_POP = 'pop',
	UI_WM_STATIC = 'static',
	UI_MODE_NORMAL = 'normal',
	UI_MODE_REQUEST = 'request',
	UI_MODE_REQUEST_XML = "<table style='width:350px;'><tr><td align='center' valign='bottom'><div id='wsdn_widget' style='width:0px;height:0px;overflow:hidden;'></div></td></tr></table>",
	BROWSER_IE = 'ie',
	BROWSER_IE7 = 'ie7',
	BROWSER_FIREFOX = 'ff',
	/**
	 * 常量
	 */
	STYLE_VALUE_AUTO = 'auto',
	STYLE_VALUE_ABSOLUTE = 'absolute',
	STYLE_VALUE_BLOCK = 'block', 
	STYLE_VALUE_NONE = 'none',    
	STYLE_VALUE_VISIBLE = 'visible',
	STYLE_VALUE_POINTER = 'pointer',
	STYLE_UNIT_PX = 'px',
	/**
	 *
	 */
	 TAG_A = 'a',
	 TAG_ATTRIBUTE_HREF = 'href',
	 TAG_ATTRIBUTE_STYLE = 'style',
	 TAG_ATTRIBUTE_FLOAT = 'float',
	 TAG_ATTRIBUTE_DISPLAY = 'display',
	 TAG_ATTRIBUTE_INNERHTML = 'innerHTML',
	 TAG_ATTRIBUTE_BACKGROUND = 'background',
	 TAG_ATTRIBUTE_WIDTH = 'width',
	 TAG_ATTRIBUTE_HEIGHT = 'height',
	 TAG_ATTRIBUTE_FILTER = 'filter',
	 TAG_ATTRIBUTE_OPACITY = 'opacity',
	 TAG_ATTRIBUTE_BORDER = 'border',
	 
	 TAG_VALUE_JSVOID = 'javascript:void(0);',	 
	/**
	 * 操作命令字
	 */
	CMD_CLOSE = 'close',
	CMD_NORMAL = 'normal',
	CMD_MAX = 'max',
	CMD_MIN = 'min',	
	CMD_CACHE_NAMECARD = 'cachenamecard',
	CMD_CACHE_MSGHISTORY = 'scache',
	CMD_CALL = 'call',
	CMD_CANCEL = 'cancel',
	CMD_CHAT = 'chat',
	CMD_CONTACT = 'contact',
	CMD_CLEAR_MSG = 'clearmsg',
	CMD_CLEAR_INPUTS = 'clearinputs',
	CMD_CLEAR_NOTES = 'clearnote',
	CMD_CLEAR_CONTACT = 'clearcontact',
	CMD_CLEAR_NAMECARD = 'clearnamecard',
	CMD_ECHO_MSG = 'echomsg',
	CMD_ECHO_CONTACT = 'echocontact',
	CMD_INIT_SHOW = 'initshow',
	CMD_INIT = 'init',
	CMD_INVITE = 'invite',
	CMD_IPR = 'IPr',
	CMD_LIST = 'list',
	CMD_MSG = 'msg',
	CMD_NAMECARD = 'namecard',
	CMD_NOTE = 'note',
	CMD_NOTE_STATE = 'notestate',
	CMD_PUSH = 'push',
	CMD_RESTORE = 'restore',
	CMD_RESTORE_MSGHISTORY = 'rcache',
	CMD_SALESLEADS = 'salesleads',
	CMD_SEND_NOTE = 'sendnote',
	CMD_SHOW = 'show',
	CMD_SHOW_NAMECARD = 'shownamecard',
	CMD_SHOW_CALL = 'showcall',
	CMD_SHOW_CHAT = 'showchat',
	CMD_SHOW_CONTACT = 'showcontact',
	CMD_SHOW_INVITE = 'showinvite',
	CMD_SHOW_LIST = 'showlist',
	CMD_SHOW_NOTE = 'shownote',
	CMD_SHOW_NOTE_STATE = 'shownotestate',
	CMD_SHOW_MSG = 'showmsg',
	CMD_SHOW_XMS = 'showxms',
	CMD_SHOW_SWITCHER = 'showswitcher',
	CMD_SWITCHER = 'switcher',
	CMD_XMS = 'xms',
	CMD_INIT_MOVIE = 'InitMovie', // 设定是否使用初始动态效果（比如，进入新页面时就显示动态UI效果）
	CMD_MOVIE = 'Movie', // 设定是否使用动态UI效果
	
	PROPERTY_USER_STATE = 'us',
	/**
	 * 内置文字 - 有外部组织导入
	 */
	LANG_MULTI_DOTS = '...',
	
	/**
	 * 格式化文字
	 */
	LITERAL_FORMAT_ECHO_MSG = "<div %1 id='%6'><strong>%2 %3 %4</strong><br/>%5</div>",
	LITERAL_FORMAT_ECHO_NORMAL_MSG = "<div %1 id='%4'><strong>%2</strong><br/>%3</div>",
	LITERAL_FORMAT_ECHO_CONTACT_TITLE = "<div %1 ><strong>%2 %3 %4</strong></div>",
	LITERAL_FORMAT_ECHO_CONTACT_BODY = "<div id='%6' %1 ><strong>%2</strong>%3</div>",
	LITERAL_FORMAT_PRESENCE = "<div %1 >%2</div>",
	/**
     * Widget ids
     */	
	ELEMENT_ID_WIDGET = 'wsdn_widget', 
	ELEMENT_ID_WIDGET_CHAT = 'wsdn_widget_chat',
	ELEMENT_ID_WIDGET_ANCHOR_WRAPPER = 'wsdn_widget_anchor_wrapper', 
	ELEMENT_ID_WIDGET_ANCHOR = 'wsdn_widget_anchor', 
	ELEMENT_ID_WIDGET_ANCHOR_TITLE = 'wsdn_anchorT',
	ELEMENT_ID_WIDGET_EXPO = 'wsdn_widget_expo', 
	ELEMENT_ID_WIDGET_EXPO_CURRENT = ELEMENT_ID_WIDGET_CALL,
    ELEMENT_ID_WIDGET_TITLE = 'wsdn_widget_title', 
	ELEMENT_ID_WIDGET_LIST = 'wsdn_widget_list', 
	ELEMENT_ID_WIDGET_LIST_ITEMS = 'wsdn_list_items',    
	ELEMENT_ID_WIDGET_LIST_TITLE = 'wsdn_widget_list_title',
	ELEMENT_ID_WIDGET_CHAT_MAX = 'wsdn_widget_chat_max',	
	/**
	 * 顶部、底部专用切换‘留言’
	 */
	ELEMENT_ID_WIDGET_NOTE_ANCHOR_SWITCHER = 'wsdn_note_anchor_switcher',
	ELEMENT_ID_WIDGET_CONTACT_ANCHOR_SWITCHER = 'wsdn_contact_anchor_switcher',
	/**
     * Widget Class
     */
	ELEMENT_CLASS_MSG_FRONTIER = " class='message_qiantai' ", 
	ELEMENT_CLASS_MSG_BACKENDS = " class='message_huotai' ", 
	ELEMENT_CLASS_MSG_SYS = " class='message_tishi' ", 
	ELEMENT_CLASS_MSG_XMS = " class='message_duanxin' ", 
	ELEMENT_CLASS_MSG_PRESENCE = " class='wsdn_echo_msg_presence' ",    
	ELEMENT_CLASS_WIDGET_CHAT_MAX = 'border wsdn_widget_blue', // widget chat max window style class
	
	/**
	 *
	 */
	WINDOW_EVENT_KEY_CTRL = 'ctrlKey',
	WINDOW_EVENT_KEY = 'keyCode',
	/**
     * 消息
     */
	ELEMENT_ID_WIDGET_ECHO = 'wsdn_echo_msg', 
	ELEMENT_ID_WIDGET_MSG_INPUT = 'wsdn_msg', 
	ELEMENT_ID_WIDGET_PRESENCE = 'wsdn_echo_presence', 
	/**
     * 名片
     */
	ELEMENT_ID_WIDGET_NAMECARD = 'wsdn_namecard', 
	ELEMENT_ID_WIDGET_NAMECARD_ITEM_PREFIX = 'wsdn_namecard_i', // 名片条目前缀
	ELEMENT_ID_WIDGET_NAMECARD_I1 = 'wsdn_namecard_i1', // 部门
 	ELEMENT_ID_WIDGET_NAMECARD_I2 = 'wsdn_namecard_i2', // 姓名
 	ELEMENT_ID_WIDGET_NAMECARD_I3 = 'wsdn_namecard_i3', // 电话
 	ELEMENT_ID_WIDGET_NAMECARD_I4 = 'wsdn_namecard_i4', // Email
 	ELEMENT_ID_WIDGET_VALIDCODE = 'wsdn_img_authencode',   
	/**
     * 默认提交热键控制
     */
	ELEMENT_ID_WIDGET_CONTROL_ENTERKEY = 'wsdn_rdoCtrl',    
	/**
     * 电话
     */
	ELEMENT_ID_WIDGET_CALL = 'wsdn_widget_call',
	ELEMENT_ID_WIDGET_TELPHONE_NUMBER = 'wsdn_ti_number', 
	ELEMENT_ID_WIDGET_TELPHONE_NICKNAME = 'wsdn_ti_nickname', 
	ELEMENT_ID_WIDGET_TELPHONE_COUNTRY = 'wsdn_ti_country', 
	ELEMENT_ID_WIDGET_TELPHONE_AREA = 'wsdn_ti_area', 
	ELEMENT_ID_WIDGET_TELPHONE_EXTENSION = 'wsdn_ti_extension', 
	ELEMENT_ID_WIDGET_TELPHONE_VALIDCODE = 'wsdn_ti_vcode', 
	WINDOW_NAME_TELPHONE_STATE = 'wsdn_call_state_popwin',    
	/**
     * 填写联系方式
     */
 	ELEMENT_ID_WIDGET_CONTACT_WRAPPER = 'wsdn_contact_wrapper',
	ELEMENT_ID_WIDGET_CONTACT = 'wsdn_widget_contact', 
	ELEMENT_ID_WIDGET_CONTACT_NAME = 'wsdn_ci_name', 
	ELEMENT_ID_WIDGET_CONTACT_CORP = 'wsdn_ci_corp', 
	ELEMENT_ID_WIDGET_CONTACT_OFFICEPHONE = 'wsdn_ci_tel', 
	ELEMENT_ID_WIDGET_CONTACT_OFFICEMAIL = 'wsdn_ci_email', 
	ELEMENT_ID_WIDGET_CONTACT_WEBSITE = 'wsdn_ci_website', 
	ELEMENT_ID_WIDGET_CONTACT_IM = 'wsdn_ci_im',    
	/**
     * 留言联系方式
     */
 	ELEMENT_ID_WIDGET_NOTE_WRAPPER = 'wsdn_note_wrapper',
	ELEMENT_ID_WIDGET_NOTE = 'wsdn_widget_note',	
	ELEMENT_ID_WIDGET_NOTE_MAX = 'wsdn_note_popW', // 
	ELEMENT_ID_WIDGET_NOTE_NAME = 'wsdn_ni_name', 
	ELEMENT_ID_WIDGET_NOTE_CORP = 'wsdn_ni_corp', 
	ELEMENT_ID_WIDGET_NOTE_OFFICEPHONE = 'wsdn_ni_tel', 
	ELEMENT_ID_WIDGET_NOTE_OFFICEMAIL = 'wsdn_ni_email', 
	ELEMENT_ID_WIDGET_NOTE_WEBSITE = 'wsdn_ni_website', 
	ELEMENT_ID_WIDGET_NOTE_IM = 'wsdn_ni_im', 
	ELEMENT_ID_WIDGET_NOTE_MSG = 'wsdn_ni_msg',    
	/**
     * 列表数据属性名称
     */
	PROPERTY_EID = 'eid',
	PROPERTY_STATE = 'state',
	PROPERTY_ADDON = 'ado',
	PROPERTY_WSID = 'wsid',	
	PROPERTY_IS_LIST = 'islist',
	PROPERTY_LISTDATA = 'listdata',    
	PROPERTY_CHATMSG_HISTORY = 'hisM',
	PROPERTY_ANCHOR_TITLE = 'anchorT',
	PROPERTY_CORP_NAME = 'corp',
	PROPERTY_CORP_TEL = 'phone',
	PROPERTY_CORP_EMAIL = 'email',
	PROPERTY_GREETINGS = 'greet',
	PROPERTY_PRESENCE_FRONTIER = 'pA',
	PROPERTY_INVITATIONS = 'invite',
	
	/**
	 * 用于缓存界面xhtml的属性名称与其element id保持一致
	 */
	PROPERTY_WIDGET_CURRENT = '',	// 用于“顶部”、“底部”模式中确定当前显示widget id
	PROPERTY_XML_CHAT_NORMAL = ELEMENT_ID_WIDGET_CHAT,
	PROPERTY_XML_CHAT_MAX = ELEMENT_ID_WIDGET_CHAT_MAX,
	PROPERTY_XML_NOTE = ELEMENT_ID_WIDGET_NOTE,
	PROPERTY_XML_CONTACT = ELEMENT_ID_WIDGET_CONTACT,
	PROPERTY_XML_CALL = ELEMENT_ID_WIDGET_CALL,
	
	PROPERTY_VALUE_TT = 'TT',
	/**
     * 动画特效配置信息
     */	
	WIDTH_WIDGET_ANCHOR = 34, HEIGHT_WIDGET_ANCHOR = 300, // anchor width, height
	WIDTH_WIDGET_LIST = 144, HEIGHT_WIDGET_LIST = STYLE_VALUE_AUTO, // list width, height
	WIDTH_WIDGET_CANVAS = 252, HEIGHT_WIDGET_CANVAS = 300, // widget canvas width, height
	WIDTH_WIDGET_EXPO = 230, HEIGHT_WIDGET_EXPO = 300, // expo canvas width, height
	WIDTH_WIDGET_CALL = 230, HEIGHT_WIDGET_CALL = 300, // call canvas width, height
	WIDTH_WIDGET_NOTE = 230, HEIGHT_WIDGET_NOTE = 300, // note canvas width, height
	WIDTH_WIDGET_CHAT_MAX = 540, HEIGHT_WIDGET_CHAT_MAX = 422, // widget chat max window width, 
	
	WINDOW_STATE_HISTORY = [], // 用于缓存Window窗体大小历史数据的数组
	WIDTH_WIDGET_CURRENT = 0, // widget current width
	HEIGHT_WIDGET_CURRENT = 0, // widget current height
	STYLE_BORDER_EXPAND = '4px solid #555555', // 动态伸缩时使用的边框css
	STYLE_BORDER_DEFAULT = '1px solid #555555', // 动态伸缩完成时使用的边框css
	STYLE_NOBORDER = '0px',
	STYLE_OPACITY_TRANSPARENT = 'alpha(opacity=0)', // 透明css
	STYLE_OPACITY_PARAMED = 'alpha(opacity=%1)',
	PIXEL_WIDTH_WIDGET_EXPO = 0, // 用于标识并设置widget_expo是否处于展开状态或者是折叠状态的width大小（像素）
	PIXEL_HEIGHT_WIDGET_EXPO = 0, // 用于标识并设置widget_expo是否处于展开状态或者是折叠状态的height大小（像素）
	SLIDER_DIRECTION_HORIZONTAL = 'w',
	SLIDER_DIRECTION_VERTICAL = 'h',
	SLIDER_DIRECTION_ALL = 'a',
	SLIDER_DIRECTION_CURRENT = SLIDER_DIRECTION_HORIZONTAL,
	STATE_WINDOW = -1, // -1, init-invisible; 0, min-window; 1, normal-window; 2, max-window.
	STATE_WINDOW_SLIDING = -1,
	TIMER_STEP_SLIDER = 8, // FOR splashWidget USE
	/**
	 * function declarations
	 */
	FUNCTION_NAME_EXPANDO,
	FUNCTION_NAME_FADE,
	FUNCTION_NAME_SLIDER,
	FUNCTION_NAME_SLIDER_TRIGGER,
	FUNCTION_NAME_EXPO_SLIDER_TRIGGER,
	// -1, 初始状态; 0, sliding; 1, slided.
	FUNCTION_NAME_SLIDE_INOUT,
	FUNCTION_NAME_SAVE_CHATHISTORY;
    /***********************STAGE 9：建立client基本界面ui‘消息槽’***********************/
	/**
	 * 将指定echo的滚动条滚动到底部
	 * @param {Object} echo
	 */
	function scrollIntoBottom(echo){
		if (echo) 
		{
			try {
                if (X.msie7) {
                    X.at(function(){
                        echo.scrollTop = echo.scrollHeight;
                    }, 0); // BUGFIX - 最大化窗口在IE7中不能正确地将滚动条滚动到底部
                }
                else {
                    echo.scrollTop = echo.scrollHeight; // BUGFIXES #217 - 将滚动条滚动到底部 -> // X.$(idiv).scrollIntoView(false);
                }
            } 
            catch (e) {
                X.LOG(e);
            }
		}
	}
    	
	/**
	 * 缓存并清空指定widget界面内容
	 * @param {Object} widgetId
	 */
	function cacheWidgetInnerXml(widgetId)
	{
		if (X.isVS(widgetId))
		{
			try
			{
				Wc.ac(widgetId,X.$(ELEMENT_ID_WIDGET)[TAG_ATTRIBUTE_INNERHTML]);
				X.$(ELEMENT_ID_WIDGET)[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
			}catch(e)
			{
				X.LOG(e);
			}
		}
	}
    
	function AnchorEvent()
	{
		var a = arguments,
		anchor = X.$(ELEMENT_ID_WIDGET_ANCHOR);
		if (!X.isO(anchor))
		{
			return;
		}
		if (a[0] == 0 )
		{
			anchor.onmouseover = null;
		}
		else
		{
			anchor.onmouseover = FUNCTION_NAME_SLIDER_TRIGGER;
		}
	}
	/**
     * 构造用户ui设置模型
     */
    U.uimodel = function(p, m)
    {
        this.id = W.udp + p + "_" + Wc.ac(PROPERTY_WSID);
        this.x = m.x ? m.x : 0;
        this.y = m.y ? m.y : 0;
        this.width = m.width ? m.width : STYLE_VALUE_AUTO;
        this.height = m.height ? m.height : STYLE_VALUE_AUTO;
        this.display = m.visible ? STYLE_VALUE_BLOCK : STYLE_VALUE_NONE;
        this.initname = "wait";
		if (p == UI_MODE_REQUEST) 
		{
			this.initHTML = UI_MODE_REQUEST_XML;
		}
		else
		{
			this.initHTML = EMPTY;
		}
		
        var ss = m.ss, js = m.js, ts = X.msie ? 'ie' : '', template = Wc.ac(PROPERTY_UI_STYLE_CURRENT);
        
        /**
         * 支持在安裝代碼時指定使用的介面模板類型：
         * 	參數名為st，默認取值範圍是
         * 		0 - 默認類型模板；
         * 		2 - 彈出窗口；
         * 		4 - 浮動圖標；
         * 		8 - 嵌入固定鏈接（圖標）（需配合wm參數）
         * 		100 - 合作夥伴定制類型（需配合pid參數）
         * 界面模板类型不再使用系统Backend控制方式，而是直接在Js脚本中根据“默认约定”进行处理；
         * 	since 2009-07-11 by gsyn77
         */
        if (template) {
            switch (template) {
                case '0':
                    template = 'normal%1.js';
                    break;
                case '2':
                    template = 'pop%1.js';
                    break;
                case '4':
                    template = 'icon%1.js';
                    break;
                default:
                    template = 'normal%1.js';
                    break;
            }
        }
		else
		{
			template = m.url;
		}
        /*
         * atWhere: center, left, top, right, bottom - 可以两两组合如：
         *	left|top，left|bottom，right|top，right|bottom，
         * 	left|center，right|center，top|center，bottom|center
         * 此时，x，y含义也不相同
         * 	x指Panel的左上角X坐标与left或right边距
         * 	y指Panel的左上角Y坐标与top或bottom边距
         */
        this.atWhere = X.isVS(Wc.ac(UI_POSITION)) ? Wc.ac(UI_POSITION) : (X.isVS(m.atWhere) ? m.atWhere : UI_POSITION_DEFAULT);
        this.position = STYLE_VALUE_ABSOLUTE;
		// normal%1 -> (左中)normal1.html, (右中)normal2.html, (左下)normal3.html,(右下) normal4.html
        if (W.pid) {
	        this.url = template ? X.surl(template.replace('%1', [Wc.ac(UI_PLACE).toString(), ts, '.', W.pid].join('')), Ui.urlbase) : EMPTY;
	    }
	    else {
	        this.url = template ? X.surl(template.replace('%1', [Wc.ac(UI_PLACE).toString() , ts].join('')), Ui.urlbase) : EMPTY;
	    }
        this.stylesheet = {};
        /*
	this.stylesheet = {};
    if (ss) {
        this.stylesheet[BROWSER_IE] = ss.ie ? X.surl(ss.ie, Ui.urlbase) : EMPTY;
        this.stylesheet[BROWSER_IE7] = ss.ie7 ? X.surl(ss.ie7, Ui.urlbase) : EMPTY;
        this.stylesheet[BROWSER_FIREFOX] = ss.ff ? X.surl(ss.ff, Ui.urlbase) : EMPTY;
    }    
    */
	/**
	 * #289
	 * @since 2009-07-28 by gsyn77
	 */
	this.stylesheet = {};
	var prefix = '%1css/color_%2_%3'.replace('%1',Wc.ac(UI_KIND) == 'sys'  ?  [Wc.ac(UI_STYLE),''].join('/') : [Wc.ac(PROPERTY_WSID),Wc.ac(UI_STYLE)].join('/')).replace('%2',Wc.ac(UI_STYLE)).replace('%3',Wc.ac(UI_PLACE));
	this.stylesheet[BROWSER_IE] = X.surl([prefix,'.css'].join(''),Ui.urlbase);
	this.stylesheet[BROWSER_IE7] = X.surl([prefix,'.css'].join(''),Ui.urlbase);
	this.stylesheet[BROWSER_FIREFOX] = X.surl([prefix,'_firefox.css'].join(''),Ui.urlbase);
        this.javascript = js ? X.surl(js, Ui.urlbase) : EMPTY;
        
        Ui[p] = this;
    };
    /**
     * 负责处理<iq query='init'/>命令字
     * @param {Object} stanza
     */
    U[CMD_IPR] = function(na)
    {
        if (!X.isO(na) || !X.isO(na.query) || X.trim(na.query) != CMD_INIT) 
        {
            return;
        }
        var data = na.store, p, ui, _authenurl, modes, idx, mode;
        // 首先处理非空string属性，这些属性与_bag中的属性名相同：
        // wsid, sid, enc, lang, corp, phone, email, greet
        for (p in data) 
        {
            if (data.hasOwnProperty(p) && X.isVS(data[p])) 
            {
                Wc.ac(p, UEC(data[p])); // 解码并存储
            }
        }
        // 处理 ELEMENT_ID_WIDGET_ANCHOR_TITLE 数组
		if (X.isA(data.anchorT) && data.anchorT.length > 0)
		{
			Wc.ac(PROPERTY_ANCHOR_TITLE,data.anchorT);
		}
        // 处理invite数组
        if (X.isA(data.invite) && data.invite.length > 0) 
        {
            Wc.ac(PROPERTY_INVITATIONS, data.invite);
        }
		// 设定是否使用初始动态效果（比如，进入新页面时就显示动态UI效果）
		if (data[CMD_INIT_MOVIE])
		{
			Wc.ac(CMD_INIT_MOVIE,data[CMD_INIT_MOVIE]);
		}
		// 设定是否使用动态UI效果
		if (data[CMD_MOVIE])
		{
			Wc.ac(CMD_MOVIE,data[CMD_MOVIE]);
		}
        ui = data.ui ? data.ui : null;
        if (ui) 
        {
            if (X.isVS(ui.kind)) 
            {
                Wc.ac(UI_KIND, ui.kind); // 界面模式：sys - 默认使用系统界面模式，user - 使用用户自定义界面模式
            }
            if (X.isVS(ui.style)) 
            {
                Wc.ac(UI_STYLE, ui.style); // sys界面模式下使用的StyleSheet（Color）类型编号:0，默认；1~8
            }            
			//  如果未指定，那么默认为底部（0）
            if (!X.isVS(ui.place)) 
            {
				ui.place = 0; 
            }			
			
            // sys界面模式下的位置
            // 位置编号 - 下中（0）、左中（1）、右中（2）、右下（3）、左下（4）、上中（5）		
            Wc.ac(UI_PLACE, ui.place);
            Wc.ac(UI_POSITION, UI_POSITIONS[ui.place]);
                        
            if (ui.place == 0 || ui.place == 5) 
            {
                SLIDER_DIRECTION_CURRENT = SLIDER_DIRECTION_VERTICAL;
                UI_ATWHERE = 1;
            }
            /**
             * INCLUDE: 引用d*(.js)脚本文件来设置界面大小参数的值
             */
            /**
 * 左右+居中(+列表) 各widget空间大小设置参数 - 此文件内容由后台或手工设定
 */
// anchor width, height
WIDTH_WIDGET_ANCHOR = 34;
HEIGHT_WIDGET_ANCHOR = 97; 
// list width, height
WIDTH_WIDGET_LIST = 144;
HEIGHT_WIDGET_LIST = STYLE_VALUE_AUTO; 
// widget canvas width, height
WIDTH_WIDGET_CANVAS = 252;
HEIGHT_WIDGET_CANVAS = 300; 
// expo canvas width, height
WIDTH_WIDGET_EXPO = 230;
HEIGHT_WIDGET_EXPO = 300; 
// call canvas width, height
WIDTH_WIDGET_CALL = 230;
HEIGHT_WIDGET_CALL = 300; 
// note canvas width, height
WIDTH_WIDGET_NOTE = 230;
HEIGHT_WIDGET_NOTE = 300; 
// widget chat max window width, 
WIDTH_WIDGET_CHAT_MAX = 540;
HEIGHT_WIDGET_CHAT_MAX = 422; 

             
            if (Wi.WM != UI_WM_POP & X.isVS(ui.WM)) {
                Wi.WM = ui.WM.toLowerCase(); // 浮动 - 'fly', 固定 - 'static'            
            }
            if (Wi.WM == UI_WM_STATIC && [Wc.ac(PROPERTY_UI_STYLE_CURRENT)].join(EMPTY) == '2') {
                UI_ATWHERE = 2; //固定链接方式
            }
            // 所有页面、css和脚本文件的根路径
            if (X.isVS(ui.urlbase)) 
            {
                Ui.urlbase = ui.urlbase; // 界面url根路径
            }
            if (X.isVS(ui.logo)) 
            {
                // logo路径：可使用相对路径（相对于base）或者是绝对url地址 —— 使用是否‘http://’开头作为区别
                Ui.logo = X.surl(ui.logo, ui.base);
				Ui.logo = Ui.logo.replace('.swf','.gif');
            }
            // 所有图片的根路径
            if (X.isVS(ui.imagebase)) 
            {
            	/**
			 * #289
			 * @since 2009-07-28 by gsyn77
			 */
			var size = ui.imagebase.length;
			// bugfix with IE  - cannot use [index] since 2009-08-05 by gsyn77
			if (ui.imagebase[size-1] == '/' || ui.imagebase.substring(size-1) == '/') ui.imagebase = ui.imagebase.substring(0,size-1);
			if (ui.place == 100) { // 如果是底部工具條 ui Template
				ui.imagebase = [ui.imagebase, ui.style].join('/');
			}
			else if (ui.kind != 'sys') // user mode ui template 
			{
				ui.imagebase = [ui.imagebase, Wc.ac(PROPERTY_WSID), ui.style].join('/');
			}
			else // sys mode ui template 
			{
				ui.imagebase = [ui.imagebase, ui.style].join('/');
			}
                Ui.imagebase = X.surl(ui.imagebase, ui.base);
            }
            // 验证码地址
            if (X.isVS(ui.authenurl)) 
            {
                _authenurl = ui.authenurl.toLowerCase();
                Ui.authenurl = X.surl(_authenurl);                
            }    
			
			// #242 - 上传Flash根地址，如：http://service.webeye.net.cn/livefu/
			if (X.isVS(ui.livefurl))
			{			
				Ui.livefurl = X.surl(ui.livefurl.toLowerCase());
			}
			// #242 - Flash File Upload Service Uri - 由webeye service端或javascript生成服务负责指定上传地址
	        if (X.isVS(ui.livefcurl)) {
	            Ui.livefcurl = X.surl(ui.livefcurl.toLowerCase());
	        }
	        // #242 - 页面内即时通讯状态下Flash文件上传弹出窗口路径
	        if (X.isVS(ui.livefcwurl)) {
	            Ui.livefcwurl = X.surl(ui.livefcwurl.toLowerCase());
	        }
			  
            modes = X.isO(ui.mode) ? ui.mode : null;
            // 逐一构造user.ui[mode]
            if (modes) 
            {
                p = null;
                for (p in modes) 
                {
					mode = modes[p];
					if (mode) 
					{
						if (p == UI_MODE_NORMAL) 
						{
							// 使用 Wi.choose(UI_MODE_NORMAL)获取对应WidgetPanel
							new U.uimodel(p, mode);
						}
						if (p == UI_MODE_REQUEST) 
						{							
							// 使用 Wi.choose(UI_MODE_REQUEST)获取对应WidgetPanel
							Wi.WP[p] = Wi.build(p, new U.uimodel(p, mode));
						}
					}
                }
            }
            // 开始加载界面并初始化数据
            W.UST(CMD_NORMAL, CMD_INIT); // 使用U['ILO']命令替代 2009-04-24 commented by gsyn77
        }
    };
    /**
     * 最小化当前Panel
     */
    W.USB(CMD_MIN, function()
    {
		var a = arguments,anchor = X.$(ELEMENT_ID_WIDGET_ANCHOR), 
		anchorP = X.$(ELEMENT_ID_WIDGET_ANCHOR_WRAPPER), 
		widget = X.$(ELEMENT_ID_WIDGET);
		
        
        // 缓存并清空指定widget id的界面innerHTML
        if (X.isVS(a[0])) 
        {
        }
        else 
        {
            if (STATE_WINDOW < 1 && Wc.ac(PROPERTY_IS_LIST)) 
            {
                widget = X.$(ELEMENT_ID_WIDGET_LIST);
				WIDTH_WIDGET_CURRENT = WIDTH_WIDGET_LIST;
				HEIGHT_WIDGET_CURRENT = HEIGHT_WIDGET_LIST;
            }
            else 
            {
                WINDOW_STATE_HISTORY.push({
                    ws: STATE_WINDOW,
                    el: widget,
                    w: parseInt(widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH]),
                    h: parseInt(widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT])
                });
            }
            
            AnchorEvent(0);
            FUNCTION_NAME_SLIDER(1, anchorP, WIDTH_WIDGET_ANCHOR, HEIGHT_WIDGET_ANCHOR, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
            {
                FUNCTION_NAME_SLIDER(-1, widget, WIDTH_WIDGET_CURRENT, HEIGHT_WIDGET_CURRENT, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                {
                    STATE_WINDOW = 0; // 
                    AnchorEvent();
                });
            });
        }
        
        STATE_WINDOW = 0; // 设置当前window为min-window状态
        unBindKey();
    });
    /**
     * 最大化 Panel
     */
    W.USB(CMD_MAX, function()
    {
        var widget = X.$(ELEMENT_ID_WIDGET), rW, rH;
        FUNCTION_NAME_EXPO_SLIDER_TRIGGER(-1, function()
        {
            // ‘淡入’效果
            FUNCTION_NAME_FADE(-1, widget, function()
            {
                widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_BORDER] = STYLE_BORDER_EXPAND;
                Ui[CMD_CACHE_MSGHISTORY](); // 缓存当前对话内容
                Ui[CMD_CLEAR_MSG](); // 清除对话内容
                Wc.ac(PROPERTY_XML_CHAT_NORMAL, widget[TAG_ATTRIBUTE_INNERHTML]); // 缓存小对话窗口innerHTML
                widget[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
                
                rW = parseInt(widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH]);
                rH = parseInt(widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT]);
                WINDOW_STATE_HISTORY.push({
                    w: rW,
                    h: rH
                });
                
                FUNCTION_NAME_EXPANDO(widget, WIDTH_WIDGET_CHAT_MAX, HEIGHT_WIDGET_CHAT_MAX, rW, rH, function()
                {
                    widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_BORDER] = STYLE_BORDER_DEFAULT;
                    //widget.className = ELEMENT_CLASS_WIDGET_CHAT_MAX;
                    if (X.msie) 
                    {
                        widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_FILTER] = STYLE_OPACITY_TRANSPARENT;
                    }
                    else 
                    {
                        widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_OPACITY] = 0;
                    }
                    widget[TAG_ATTRIBUTE_INNERHTML] = Wc.ac(PROPERTY_XML_CHAT_MAX); // 读取缓存的max状态Window的innerHTML
                    FUNCTION_NAME_FADE(1, widget, function()
                    {
                        STATE_WINDOW = 2; // 设置当前为max-chat状态
                        WIDTH_WIDGET_CURRENT = WIDTH_WIDGET_CHAT_MAX;
                        HEIGHT_WIDGET_CURRENT = HEIGHT_WIDGET_CHAT_MAX;
                        
                        Ui[CMD_CLEAR_MSG](); // 清除对话内容
                        Ui[CMD_RESTORE_MSGHISTORY](); // 读取缓存对话内容
                        Ui.cTi(Wc.ac(CMD_CACHE_NAMECARD).i2 || Wc.ac(PROPERTY_CORP_NAME)); // 修改标Window题栏内容
                        Ui.fvcode(); // 获取电话验证码图片
                        bindKey(); // 绑定输入键盘事件
                    });
                });
            });
        });
    });
	/**
     * 初始状态
     */
    W.USB(CMD_NORMAL, function(m)
    {
        var p;
        if (m == CMD_INIT) 
        {
            Wi.TG(CMD_NORMAL, function()
            {
                p = Wi.choose(UI_MODE_NORMAL);
                
                if (p) 
                {
                    Wc.ac(UI_MODE_NORMAL, p);
                }
                                                
                // 左、右
                Wc.ac(PROPERTY_XML_CHAT_MAX, X.$(ELEMENT_ID_WIDGET_CHAT_MAX)[TAG_ATTRIBUTE_INNERHTML]);
                Wc.ac(PROPERTY_XML_NOTE, X.$(ELEMENT_ID_WIDGET_NOTE)[TAG_ATTRIBUTE_INNERHTML]);
                X.$(ELEMENT_ID_WIDGET_CHAT_MAX)[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
                
                /*
                 * 串行化初始动画
                 */
                Ui[CMD_INIT_SHOW](function()
                {
                    // 由服务端控制是否进行动态UI演示
                    if (Wc.ac(CMD_INIT_MOVIE)) 
                    {
                        FUNCTION_NAME_SLIDER_TRIGGER(function()
                        {
							/**
							 * #282 - Wc.ac(CMD_INIT_MOVIE) == 1:滑出缩回，2：滑出不缩回
							 * 2009-07-15 by gsyn77
							 */
							if (Wc.ac(CMD_INIT_MOVIE) == 1) {
								var initH = X.at(function(){
									FUNCTION_NAME_SLIDER_TRIGGER();
									X.atc(initH);
								}, 2500);
							}
                        });
                    }
                });
                
                
                p = Wi.choose(UI_MODE_REQUEST);
                if (p) 
                {
                    Wc.ac(UI_MODE_REQUEST, p);
                    X.$(p.id)[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
                }
                
            });
        }
        else 
        {
            Ui[CMD_INIT_SHOW]();
        }
    });
    /**
     * 关闭 Panel - 负责将当前modal界面（normal, max）隐藏
     * @param no parameters - client system auto determined which Panel to be closing,
     * and toggle ui modal to last one.
     */
    W.USB(CMD_CLOSE, function()
    {
        var a = arguments, anchor = X.$(ELEMENT_ID_WIDGET_ANCHOR), anchorP = X.$(ELEMENT_ID_WIDGET_ANCHOR_WRAPPER), widget = X.$(ELEMENT_ID_WIDGET);
                
        if (STATE_WINDOW == 2) // 如果是'max-windowed'
        {
            AnchorEvent(0);
            FUNCTION_NAME_SLIDER(1, anchorP, WIDTH_WIDGET_ANCHOR, HEIGHT_WIDGET_ANCHOR, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
            {
                widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_BORDER] = STYLE_BORDER_EXPAND;
                Ui[CMD_CACHE_MSGHISTORY](); // 缓存当前对话内容
                Ui[CMD_CLEAR_MSG](); // 清除对话内容
                widget[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
                FUNCTION_NAME_SLIDER(-1, widget, WIDTH_WIDGET_CHAT_MAX, HEIGHT_WIDGET_CHAT_MAX, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                {
                    widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_BORDER] = STYLE_BORDER_DEFAULT;
                    widget[TAG_ATTRIBUTE_INNERHTML] = Wc.ac(PROPERTY_XML_CHAT_NORMAL); // 取出小对话窗口innerHTML
                    Ui[CMD_CLEAR_MSG](); // 清除对话内容
                    Ui[CMD_RESTORE_MSGHISTORY](); // 读取缓存对话内容
                    AnchorEvent();
                });
            });
        }
        else 
        {
            AnchorEvent(0);
            FUNCTION_NAME_SLIDER(1, anchorP, WIDTH_WIDGET_ANCHOR, HEIGHT_WIDGET_ANCHOR, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
            {
                FUNCTION_NAME_EXPO_SLIDER_TRIGGER(-1, function()
                {
                    FUNCTION_NAME_SLIDER(-1, widget, WIDTH_WIDGET_CANVAS, HEIGHT_WIDGET_CANVAS, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                    {
                        AnchorEvent();
                    });
                }); // 隐藏widget_expo
            });
        }
        
        // 将Window窗口大小初始化为原始大小
        WIDTH_WIDGET_CURRENT = Wc.ac(PROPERTY_IS_LIST) ? WIDTH_WIDGET_LIST : WIDTH_WIDGET_CANVAS;
        HEIGHT_WIDGET_CURRENT = Wc.ac(PROPERTY_IS_LIST) ? HEIGHT_WIDGET_LIST : HEIGHT_WIDGET_CANVAS;
        
        WINDOW_STATE_HISTORY = []; // 清空Windows窗体大小变化历史
        STATE_WINDOW = -1; // 设置当前window为初始隐藏状态
        unBindKey();
        /*
         * 用于触发对话请求的‘cancel’事件
         */
        W.T(CMD_CANCEL);
        /**
         * 『列表专用』清除后台人员关联id和state
         */
        Wc.rm(PROPERTY_EID);
        Wc.rm(PROPERTY_STATE);
    });
    /**
     * 从min（最小化）状态还原为之前的状态
     */
    W.USB(CMD_RESTORE, function()
    {
        var anchor = X.$(ELEMENT_ID_WIDGET_ANCHOR), 
		anchorP = X.$(ELEMENT_ID_WIDGET_ANCHOR_WRAPPER), 
		widget = X.$(ELEMENT_ID_WIDGET),
		pos;
        Ui[CMD_CACHE_MSGHISTORY](); // 缓存当前对话内容
        Ui[CMD_CLEAR_MSG](); // 清除对话内容
        FUNCTION_NAME_FADE(-1, widget, function()
        {
            widget[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
            widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_BORDER] = STYLE_BORDER_EXPAND;

			pos = WINDOW_STATE_HISTORY.pop();
            FUNCTION_NAME_EXPANDO(widget, pos.w, pos.h, WIDTH_WIDGET_CURRENT, HEIGHT_WIDGET_CURRENT, function()
            {
                widget[TAG_ATTRIBUTE_INNERHTML] = Wc.ac(PROPERTY_XML_CHAT_NORMAL); // 取出小对话窗口innerHTML
                Ui[CMD_CLEAR_MSG](); // 清除对话内容
                Ui[CMD_RESTORE_MSGHISTORY](); // 读取缓存对话内容
                
				STATE_WINDOW = 1; // 设置当前window为normal-chat状态
                
                Ui.cTi(Wc.ac(CMD_CACHE_NAMECARD).i2 || Wc.ac(PROPERTY_CORP_NAME)); // 修改标Window题栏内容
                Ui.fvcode(); // 获取电话验证码图片
                widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_BORDER] = STYLE_NOBORDER;
                
                
                WIDTH_WIDGET_CURRENT = pos.w;
				HEIGHT_WIDGET_CURRENT = pos.h;
				
                bindKey();
            });
            
        });
    });
    /**
     * 拒绝邀请或取消（对话）请求
     * @param {Object} mode
     */
    W.USB(CMD_CANCEL, function(mode)
    {
        W.T(CMD_CANCEL);
    });
    /**
     * 需要用户自定义的‘界面显示’类型事件
     * 	处理方法
     * 		W.user.ui['showmsg']				// msg, 负责显示前后台输入的‘消息’及当前行为状态信息，如“正在输入文字……”等
     * 		W.user.ui['showlist']			// list, 负责显示‘人员列表’界面
     * 		W.user.ui['shownamecard']		// namecard, 负责显示‘名片’界面
     * 		W.user.ui['showcontact']			// contact, 负责显示‘留下联系方式’界面
     * 		W.user.ui['shownote']			// note, 负责显示‘留言’界面
     * 		W.user.ui['showcall']			// call, 负责显示‘电话拨叫’界面
     * 		W.user.ui['showinvite']			// invite, 负责显示‘邀请对话’界面
     * 		Ui['showchat']			// chat, 负责显示‘对话’界面
     */
    W.UB(CMD_SHOW, function()
    {
        var evtname = arguments[0], args = Array.prototype.slice.call(arguments, 1); // 得到除‘事件名称’外的所有参数数组
        if (!X.isS(evtname)) 
        {
            return; // 如果没有输入事件名称
        }
        evtname = evtname.toLowerCase();
        switch (evtname)
        {
			case CMD_XMS:
				/* 负责显示 短信提示文字
	             * args 参数说明
	             * 	{
	             * 		subject: "", // 消息标题 - 可为空字符串
	             * 		body: "", // 消息内容 - 可为空字符串
	             * 	}
	             */
                Ui[CMD_SHOW_XMS].apply(this, args);
                break;
            case CMD_MSG:
                /* 负责显示‘消息’
             * args 参数说明
             * 	{
             * 		title: "", // 消息标题 - 可为空字符串
             * 		body: "", // 消息内容 - 可为空字符串
             * 		state: "" // "active"（默认）, "LANG_PRESENCE_COMPOSING"（“正在输入文字……”） , "LANG_PRESENCE_GONE"（“对方已经退出对话。”）
             * 	}
             */
                Ui[CMD_SHOW_MSG].apply(this, args);
                break;
            case CMD_LIST:
                /* 负责显示‘人员列表’界面
             * 『目前』 args 参数说明 - 人员信息数组 groups = [{name:"",members:
             * 	[{
             * 		name: "",		// ‘姓名’或‘网页显示姓名’
             * 		id:"",			// 办公电话号码
             * 		state:1			// 状态： 1，在线；0，离线
             * 	}], ... ]
             */
                Ui[CMD_SHOW_LIST].apply(this, args);
                break;
            case CMD_NAMECARD:
                /* 负责显示‘名片’界面
             * 『目前』 args 参数说明
             * 	{
             * 		name: "",		// ‘姓名’或‘网页显示姓名’
             * 		position: "",	// ‘部门’或‘职位’
             * 		phone:"",		// 办公电话
             * 		email:""		// 办公email
             * 	}
             */
                Ui[CMD_SHOW_NAMECARD].apply(this, args);
                break;
            case CMD_CONTACT:
                /* 负责显示‘留下联系方式’界面
             * 『目前』 args 参数说明
             * 	args === null 或者 args === undefined
             */
                Ui[CMD_SHOW_CONTACT].apply(this, args);
                break;
            case CMD_NOTE:
                /* 负责显示‘留言’界面
             * 『目前』 args 参数说明
             * 	args === null 或者 args === undefined
             */
                Ui[CMD_SHOW_NOTE].apply(this, args);
                break;
            case CMD_CALL:
                /* 负责显示‘电话拨叫’界面
             * 『目前』 args 参数说明
             * 	id, 	// 主叫eid
             * 	state	// 主叫在线状态；1：在线，0：离线
             */
                Ui[CMD_SHOW_CALL].apply(this, args);
                break;
            case CMD_INVITE:
                /* 负责显示‘邀请对话’界面
             * 『目前』 args 参数说明
             * 	{
             * 		title: "", // 消息标题
             * 		body: "", // 消息内容
             * 	}
             */
                Ui[CMD_SHOW_INVITE].apply(this, args);
                break;
            case CMD_CHAT:
                /* 负责显示‘对话’界面
             * 『目前』 args 参数说明
             * 	id, 	// 后台eid
             * 	state	// 后台在线状态；1：在线，0：离线
             */
                Ui[CMD_SHOW_CHAT].apply(this, args);
                break;
            case CMD_NOTE_STATE:
                /*
             * 负责显示‘留言’提交结果信息
             */
                Ui[CMD_SHOW_NOTE_STATE].apply(this, args);
                break;
            case CMD_SWITCHER:
                /*
             * 负责显示‘通话转接’提示信息
             */
                Ui[CMD_SHOW_SWITCHER].apply(this.args);
                break;
        }
    });
    
    /*************************STAGE 10: 注册用户需要处理的‘事件’*****************************/
    if (Wc.ac(PROPERTY_WSID)) 
    {
        /**
         * 负责处理用户键盘事件
         */
        var oKEH = null, cKEH = null,        
		/**
         * 绑定用户键盘事件
         */
        bindKey = U.BindKey = function()
        {
            if (document.onkeydown) 
            {
                oKEH = document.onkeydown;
            }
            cKEH = function(e)
            {
                var evt = e || event;
                var currKey = evt.keyCode || evt.which || evt.charCode;
                U.pA.s(1);
                if (currKey == 116) 
                {
                    evt.keyCode = 0;
                    evt.returnValue = false;
                }
                
                if (!(evt[WINDOW_EVENT_KEY_CTRL]) && (evt[WINDOW_EVENT_KEY] == 13)) 
                {
					try 
					{
						X.$(ELEMENT_ID_WIDGET_MSG_INPUT).focus();
					}catch(e){
						X.LOG(e);
					}
                    Ui[CMD_ECHO_MSG]();
                    U.pA.s(0);
                    Ui[CMD_CLEAR_INPUTS]();
                    evt.returnValue = false;
                }
            };
            document.onkeydown = cKEH;
        },        /**
         * 取消绑定用户键盘事件
         */
        unBindKey = U.unBindKey = function()
        {
            if (oKEH) 
            {
                document.onkeydown = oKEH;
            }
            else 
            {
                document.onkeydown = null;
            }
            
            pA.c();
        },        
        /**
         * 负责用户‘正在输入文字……’的监控
         */
        pA = U.pA = {
            /**
             *
             * @param {Object} stat
             * -1, initial state;
             * 0, no message inputs or already send complete;
             * 1, pro-active messages has been monitored.
             */
            s: function(stat)
            {
				/**
				 * refs #232 - 支持（Js脚本中的）『文字预知』功能
				 */
				var inputs = X.$(ELEMENT_ID_WIDGET_MSG_INPUT), org;
				if (inputs && stat == 1) 
				{
					org = Wc.ac(PROPERTY_PRESENCE_FRONTIER);
					if (org != inputs.value && X.isVS(X.trim(inputs.value)))
					{
						Wc.ac(PROPERTY_PRESENCE_FRONTIER, inputs.value);
					}
					else
					{
						Wc.ac(PROPERTY_PRESENCE_FRONTIER, stat);
					}
				}
				else 
				{
					Wc.ac(PROPERTY_PRESENCE_FRONTIER, stat);
				}
            },
            /**
             *
             */
            c: function()
            {
                Wc.ac(PROPERTY_PRESENCE_FRONTIER, -1);
            }
        },        /*************************用户可以使用的‘发送消息’类型事件方法*********************************
         * 用户可以使用的‘发送消息’类型事件方法
         * 	需要用户在进行必要的数据检查之后调用 , call, chat
         * 		W.T(CMD_PUSH,'contact',args);		//	发送联系方式或留言
         * 		W.T(CMD_PUSH,'chat',args);			//	发送对话内容
         ************************************************************************************/
        /**
         * 负责检查电话号码是否合法
         */
        vCall = function()
        {
            var $ = X.$;
            // 电话号码
            if (!X.isPhone($(ELEMENT_ID_WIDGET_TELPHONE_NUMBER) ? $(ELEMENT_ID_WIDGET_TELPHONE_NUMBER).value : EMPTY)) 
            {
                // 输入的电话号码不正确，请重新输入！
                alert(UEC(LANG_PHONE_ERROR));
                $(ELEMENT_ID_WIDGET_TELPHONE_NUMBER).focus();
                return false;
            }
            // 验证码
            if (!X.isNum($(ELEMENT_ID_WIDGET_TELPHONE_VALIDCODE) ? $(ELEMENT_ID_WIDGET_TELPHONE_VALIDCODE).value : EMPTY)) 
            {
                // 请输入验证码！
                alert(UEC((LANG_VALIDCODE_ERROR)));
                $(ELEMENT_ID_WIDGET_TELPHONE_VALIDCODE).focus();
                return false;
            }
            
            return true;
        },        
		/**
         * 负责审查‘联系方式’或‘留言’中填写内容是否符合要求
         * @param cbody
         */
        vSL = function(cbody)
        {
            if (cbody && (X.isS(cbody.corp) || X.isS(cbody.name)) &&
            (X.isS(cbody.email) || X.isS(cbody.tel))) 
            {
                if (X.isVS(cbody.tel)) 
                {
                    if (!X.isPhone(cbody.tel)) 
                    {
                        //温馨提示：电话号码不正确，正确号码输入如：02083586353或01087653201-8011
                        alert(UEC(LANG_PHONE_ERROR_TIPS));
                        return false;
                    }
                }
                if (X.isVS(cbody.email)) 
                {
                    if (!X.isEmail(cbody.email)) 
                    {
                        //温馨提示：邮箱输入不正确，正确邮箱输入如：support@webeye.net.cn
                        alert(UEC(LANG_EMAIL_ERROR_TIPS));
                        return false;
                    }
                }
                
                return true;
            }
            else 
            {
                if (X.isES(cbody.corp) && X.isES(cbody.name)) 
                {
                    //'温馨提示：公司、姓名至少需填写一项。'
                    alert(UEC(LANG_CORP_TIPS));
                    return false;
                }
                if (X.isES(cbody.email) && X.isES(cbody.tel)) 
                {
                    //'温馨提示：电话、邮箱至少需填写一项。'
                    alert(UEC(LANG_PHONE_TIPS));
                    return false;
                }
            }
            return false;
        },        
        /**
         * 负责回显‘联系方式’
         * @param {Object} cbody
         */
        eSL = function(echo, cbody)
        {
            var tt = ELEMENT_CLASS_MSG_FRONTIER, tb = ELEMENT_CLASS_MSG_FRONTIER, 
			titleF = LITERAL_FORMAT_ECHO_CONTACT_TITLE, 
			bodyF = LITERAL_FORMAT_ECHO_CONTACT_BODY,
			idiv;
			
            eSLContent();
			scrollIntoBottom(echo); // echo.scrollTop = echo.scrollHeight; 
			
			/**
			 * 负责回显‘联系方式’、‘留言’消息内容
			 */
            function eSLContent(){
                // 访客在 19:00 填写联系方式如下：
                echo[TAG_ATTRIBUTE_INNERHTML] += X.format(titleF, tt, UEC(LANG_VISITOR_AT), X.Time(), UEC(LANG_CONTACT_AT));
                
                if (X.isVS(cbody.corp)) {
                    idiv = 'chis' + X.ticks().toString();
                    //"公司："
                    echo[TAG_ATTRIBUTE_INNERHTML] += X.format(bodyF, tb, UEC(LANG_TITLE_CORP), cbody.corp, idiv);
                }
                if (X.isVS(cbody.name)) {
                    idiv = 'chis' + X.ticks().toString();
                    //"姓名："
                    echo[TAG_ATTRIBUTE_INNERHTML] += X.format(bodyF, tb, UEC(LANG_TITLE_NAME), cbody.name, idiv);
                }
                if (X.isVS(cbody.tel)) {
                    idiv = 'chis' + X.ticks().toString();
                    //电话：
                    echo[TAG_ATTRIBUTE_INNERHTML] += X.format(bodyF, tb, UEC(LANG_TITLE_PHONE), cbody.tel, idiv);
                }
                if (X.isVS(cbody.website)) {
                    idiv = 'chis' + X.ticks().toString();
                    //网址：
                    echo[TAG_ATTRIBUTE_INNERHTML] += X.format(bodyF, tb, UEC(LANG_TITLE_WEBSITE), cbody.website, idiv);
                }
                if (X.isVS(cbody.email)) {
                    idiv = 'chis' + X.ticks().toString();
                    //邮箱：
                    echo[TAG_ATTRIBUTE_INNERHTML] += X.format(bodyF, tb, UEC(LANG_TITLE_EMAIL), cbody.email, idiv);
                }
                if (X.isVS(cbody.im)) {
                    idiv = 'chis' + X.ticks().toString();
                    //IM：
                    echo[TAG_ATTRIBUTE_INNERHTML] += X.format(bodyF, tb, UEC(LANG_TITLE_IM), cbody.im, idiv);
                }
            }
        },        
		/**
         * 负责检查输入消息是否合法
         */
        vMsg = function()
        {
            var sender = X.$(ELEMENT_ID_WIDGET_MSG_INPUT), //消息输入HTML Element ID 或 DOM Object
 			body = sender.value; //消息内容
            // 如果输入消息内容为非空字符串
            if (X.isVS(body)) 
            {
                return body;
            }
            else 
            {
                // 温馨提示：发送消息内容不得为空。
                alert(UEC(LANG_INPUT_EMPTY_ERROR));
                return false;
            }
        },        
        /**
         * 负责回显输入消息
         */
        eMsg = function(cbody)
        {
            var tb = ELEMENT_CLASS_MSG_FRONTIER, sender = X.$(ELEMENT_ID_WIDGET_MSG_INPUT), //消息输入HTML Element ID 或 DOM Object
         	echo = X.$(ELEMENT_ID_WIDGET_ECHO), //消息显示HTML Element ID 或 DOM Object
         	bodyF = LITERAL_FORMAT_ECHO_MSG,
		 	idiv = 'chis' + X.ticks().toString();
            // '访客在19:00说：'			
            echo[TAG_ATTRIBUTE_INNERHTML] += X.format(bodyF, tb, UEC(LANG_VISITOR_AT), X.Time(), UEC(LANG_SAID), cbody, idiv);
            scrollIntoBottom(echo); // echo.scrollTop = echo.scrollHeight; 
			sender.value = EMPTY;
        },
        /**
         * 弹出窗口
         * @param {Object} wname - 弹出窗口唯一标识名称
         * @param {Object} top	 - y
         * @param {Object} left	 - x
         * @param {Object} width
         * @param {Object} height
         */
		popW = function(url, wname, top, left, width, height){
			return X.newWin(url, wname, top, left, width, height);
		},
		/**
		 * 负责在max-window中显示留言界面
		 */
		popNote = Ui.popNote = function(){
			var contactWrapper = X.$(ELEMENT_ID_WIDGET_CONTACT_WRAPPER),
			noteWrapper = X.$(ELEMENT_ID_WIDGET_NOTE_WRAPPER);
			if (contactWrapper[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] == STYLE_VALUE_BLOCK)
			{				
				contactWrapper[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
				noteWrapper[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_BLOCK;
			}
			else{
				contactWrapper[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_BLOCK;
				noteWrapper[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
			}
		};
		
		/**
         * 负责回显并发送‘电话呼叫’相关信息
         */
        Ui[CMD_CALL] = function()
        {
            if (!vCall()) 
            {
                return;
            }
            
            var $ = X.$, cinfo = {
                nickname: $(ELEMENT_ID_WIDGET_TELPHONE_NICKNAME) ? $(ELEMENT_ID_WIDGET_TELPHONE_NICKNAME).value : EMPTY,
                country: $(ELEMENT_ID_WIDGET_TELPHONE_COUNTRY) ? $(ELEMENT_ID_WIDGET_TELPHONE_COUNTRY).value : EMPTY,
                area: $(ELEMENT_ID_WIDGET_TELPHONE_AREA) ? $(ELEMENT_ID_WIDGET_TELPHONE_AREA).value : EMPTY,
                number: $(ELEMENT_ID_WIDGET_TELPHONE_NUMBER) ? $(ELEMENT_ID_WIDGET_TELPHONE_NUMBER).value : EMPTY,
                extenstion: $(ELEMENT_ID_WIDGET_TELPHONE_EXTENSION) ? $(ELEMENT_ID_WIDGET_TELPHONE_EXTENSION).value : EMPTY,
                vcode: $(ELEMENT_ID_WIDGET_TELPHONE_VALIDCODE) ? $(ELEMENT_ID_WIDGET_TELPHONE_VALIDCODE).value : EMPTY
            },
			url,
            left = 100, top = 100, width = 320, height = 270;            
            
            // 去掉电话号码中的‘-’和‘ ’
            cinfo.number = cinfo.number.replace(' ', EMPTY).replace('-', EMPTY);
             url= W.C(cinfo); //	发送电话呼叫请求信息
             
			popW(url,WINDOW_NAME_TELPHONE_STATE,top,left,width,height);
            
            // 分机
            if (!X.isNum(cinfo.extension)) 
            {
                cinfo.extension = EMPTY;
            }
            
			// 刷新验证码图片
			X.at(function()
			{
			Ui.fvcode();
			},3000);
        };
        /**
         * 负责发送联系方式
         */
        Ui[CMD_ECHO_CONTACT] = function()
        {
            var cbody = {};
            cbody.name = X.$(ELEMENT_ID_WIDGET_CONTACT_NAME).value;
            cbody.corp = X.$(ELEMENT_ID_WIDGET_CONTACT_CORP).value;
            cbody.tel = X.$(ELEMENT_ID_WIDGET_CONTACT_OFFICEPHONE).value;
            cbody.email = X.$(ELEMENT_ID_WIDGET_CONTACT_OFFICEMAIL).value;
            cbody.website = X.$(ELEMENT_ID_WIDGET_CONTACT_WEBSITE).value;
            cbody.im = X.$(ELEMENT_ID_WIDGET_CONTACT_IM).value;
            
            U[CMD_SALESLEADS](CMD_CONTACT, cbody);
        };
        /**
         * 负责发送留言
         */
        Ui[CMD_SEND_NOTE] = function()
        {
            var cbody = {}, ret;
            cbody.name = X.$(ELEMENT_ID_WIDGET_NOTE_NAME).value;
            cbody.corp = X.$(ELEMENT_ID_WIDGET_NOTE_CORP).value;
            cbody.tel = X.$(ELEMENT_ID_WIDGET_NOTE_OFFICEPHONE).value;
            cbody.email = X.$(ELEMENT_ID_WIDGET_NOTE_OFFICEMAIL).value;
            cbody.website = X.$(ELEMENT_ID_WIDGET_NOTE_WEBSITE).value;
            cbody.im = X.$(ELEMENT_ID_WIDGET_NOTE_IM).value;
            
            var notemsg = X.$(ELEMENT_ID_WIDGET_NOTE_MSG);
            cbody.msg = notemsg ? notemsg.value : EMPTY;
            
            ret = U[CMD_SALESLEADS](CMD_NOTE, cbody);
            if (ret) 
            {
                // 提示留言已经发送消息
                Ui.echo(LANG_TIPSTITLE, UEC(LANG_NOTEHASENT));                
            }
        };
        /**
         * 负责回显并发送‘联系方式’； 或者负责发送‘留言信息’
         * sendnote和echocontact使用同一方法处理
         * @param {Object} cbody
         */
        U[CMD_SALESLEADS] = function(type, cbody)
        {
            if (vSL(cbody)) 
            {
                W.T(CMD_PUSH, type, cbody); // 调用Wc.contact()发送联系方式内容
                var echo = X.$(ELEMENT_ID_WIDGET_ECHO);
				// 2009-03-21 modified by gsyn77: 不进行echo检查 - X.isO(echo) 
                if (type == CMD_CONTACT) 
                {
                    eSL(echo, cbody); // 如果需要,回显
                    alert(UEC(LANG_CONTACTSENT)); // 用于防止访客提交两次联系方式
                }				
            }
			else
			{
				return false;
			}
			return true;
        };
        /**
         * 负责回显用户输入的消息内容，并提交给后台
         */
        Ui[CMD_ECHO_MSG] = function(msg, bSend){
            var cbody = msg ? msg : vMsg();
            if (!X.isO(bSend) || bSend == true) {
                bSend = true;
            }
			else
			{
				bSend = false;
			}
            // 如果输入消息内容为非空字符串
            if (cbody) {
                if (bSend) {
                    // 发送消息
                    W.T(CMD_PUSH, CMD_CHAT, cbody);
                }
                eMsg(cbody);
            }
        };
        /**********************需要用户自定义的‘界面显示’类型事件*******************************
         * 需要用户自定义的‘界面显示’类型事件
         * 	处理方法
         * 		W.user.ui['showmsg']				// msg, 负责显示前后台输入的‘消息’及当前行为状态信息，如“正在输入文字……”等
         * 		W.user.ui['showlist']			// list, 负责显示‘人员列表’界面
         * 		W.user.ui['shownamecard']		// namecard, 负责显示‘名片’界面
         * 		W.user.ui['showcontact']			// contact, 负责显示‘留下联系方式’界面
         * 		W.user.ui['shownote']			// note, 负责显示‘留言’界面
         * 		W.user.ui['showcall']			// call, 负责显示‘电话拨叫’界面
         * 		W.user.ui['showinvite']			// invite, 负责显示‘邀请对话’界面
         ************************************************************************************/
        /**
         * 初始化公司总机电话、Email
         * 负责在加载最初界面——‘normal’后，初始化消息内容
         */
        Ui[CMD_INIT_SHOW] = function()
        {
            var a = arguments, //
             tc = Wc.ac(PROPERTY_CORP_NAME), //
             pc = Wc.ac(PROPERTY_CORP_TEL), //
             ec = Wc.ac(PROPERTY_CORP_EMAIL),//
             bc = Wc.ac(PROPERTY_GREETINGS), //
             body, //
             anchorText = X.$(ELEMENT_ID_WIDGET_ANCHOR_TITLE), // 耳朵 HTML element
             t = UEC(Wc.ac(PROPERTY_ANCHOR_TITLE)[0]), // 耳朵中的文字
             b = UEC(bc), tb = ELEMENT_CLASS_MSG_SYS, //
             bodyF = LITERAL_FORMAT_ECHO_NORMAL_MSG, //
             listdata, //
             delayedTask, //
             blankDiv, //
             aH;
            
            function initList()
            {
                if (X.$(ELEMENT_ID_WIDGET_LIST)) 
                {
                    try 
                    {
                        listdata = Wc.ac(PROPERTY_LISTDATA);
                        // 如果当前使用‘列表’
                        if (listdata) 
                        {
                            // 读取listdata缓存数据,替换listdata中的Wsdn变量
                            listdata = listdata.replace(/\%7B/gi, "{").replace(/\%7D/gi, "}").replace(/\$\{[.\w]+\}/gi, W.CVar);
                            Wc.ac(PROPERTY_LISTDATA, listdata);
                            Wc.ac(PROPERTY_IS_LIST, true); // 标识当前为list
                            Ui[CMD_SHOW_LIST]();
                            // 修改标题文字
                            Ui.cTi(tc); // 后面的 Ui[CMD_SHOW_NAMECARD]() 已经起到相同作用
                        }
                    } 
                    catch (e) 
                    {
                        X.LOG(e);
                    }
                }
                else 
                {
                    WIDTH_WIDGET_LIST = HEIGHT_WIDGET_LIST = 0;
                }
            }
            function initHisMsg()
            {
                // 如果有对话历史信息，加载之
                var hm = Wc.ac(PROPERTY_CHATMSG_HISTORY);
                if (X.isVS(hm)) 
                {
                    body[TAG_ATTRIBUTE_INNERHTML] += hm;
                    Wc.rm(PROPERTY_CHATMSG_HISTORY);
                }
            }
            function initText()
            {
                // 修改标题文字
                // Ui.cTi(tc); // 后面的 Ui[CMD_SHOW_NAMECARD]() 已经起到相同作用
                
                // 如果使用系统默认界面模式中的‘对话’
                body = X.$(ELEMENT_ID_WIDGET_ECHO);
                if (body && tc && bc) 
                {
                    body[TAG_ATTRIBUTE_INNERHTML] += X.format(bodyF, tb, tc, b);
                    initHisMsg();
                    // 如果不是首次进入网站，则不显示欢迎消息
                    if (Wc.ac(CMD_INIT_MOVIE)) 
                    {
                    }
                    // 默认显示‘公司名称’、‘公司电话’和‘公司邮箱’
                    Ui[CMD_SHOW_NAMECARD]({
                        store: {
                            i1: EMPTY, // 部门
                            i2: tc, // 姓名
                            i3: pc, // 电话
                            i4: ec // Email
                        }
                    });
                }
            }
            // 设置圆角内文字
            if (anchorText) 
            {
                anchorText[TAG_ATTRIBUTE_INNERHTML] = t;
            }
            
            // 设置验证码图片
            Ui.fvcode();
            
            initText();
            
            initList();
            
            // 如果存在callback或者延迟的任务（如需显示历史对话消息），调用之
            delayedTask = TASKLIST_BEFORE_CUSTOM_PROCEDURE.pop();
            if (X.isF(delayedTask)) 
            {
                delayedTask.apply(this);
            }
            
            if (X.isF(a[0])) 
            {
                a[0].apply(this);
            }
        };
		/**
		 * 负责显示短信起始提示文字 - <iq />
		 * @param {Object} args
		 */
        Ui[CMD_SHOW_XMS] = function(args)
        {
            // var a = args.store; - 这个应该有问题吧？ 2009-03-21 by gsyn77
            var a = X.isVS(args.body) ? args : (args.store ? args.store : args);
            
            try 
            {
				Wc.B.SM(X.clear(a.body, ' ')); // 2009-06-11 by gsyn77 #264
				
                Ui.echo(a.subject, a.body, ELEMENT_CLASS_MSG_XMS);
                if (FUNCTION_NAME_SLIDE_INOUT(ELEMENT_ID_WIDGET) == 1) 
                {
                    FUNCTION_NAME_SLIDER_TRIGGER();
                }
                
                // 暂时取消设置浏览器window焦点
                // window.focus();
            } 
            catch (e) 
            {
                X.LOG(e);
            }
        };
		/**
         * 负责显示后台发来的消息内容和动作状态
         * @param {Object} args
         * {
         * 	from:'',//  sms 短信, txt 对话 ,  sys: 系统
         * 	_ns_: 'message',
         * 	type: 'chat',
         * 	subject: "",
         * 	body: "",
         * 	state: "" // active（默认）, LANG_PRESENCE_COMPOSING（正在输入文字）, LANG_PRESENCE_GONE（离开）
         * }
         */
        Ui[CMD_SHOW_MSG] = function(args)
        {
            var msg = '', //
         elem, //
         echo = X.$(ELEMENT_ID_WIDGET_ECHO), // HTML Element: 内容显示
         presence = X.$(ELEMENT_ID_WIDGET_PRESENCE), // HTML Element: 后台动作状态提示
         tb = EMPTY, tp = ELEMENT_CLASS_MSG_PRESENCE, //
         subject = '', //
         subjectF = '%1 %2 %3', // 张三(客服) 19:40:30
         namecard = Wc.ac(CMD_CACHE_NAMECARD), //
         bodyF = LITERAL_FORMAT_ECHO_NORMAL_MSG, //
         presenceF = LITERAL_FORMAT_PRESENCE, //
         idiv = 'chis' + X.ticks().toString(), //
         store, hm, //
         widget = X.$(ELEMENT_ID_WIDGET), //
         tmp, //
         list, //
         anchorWrapper, //
         timeoutH, //
         pres, //
         activeHistory = false;
            /**
             * 显示消息内容
             */
            function showContent()
            {
                Wc.B.SM(X.clear(msg,' ')); // 2009-06-11 by gsyn77 #264
                // BUGFIXED: 2009-02-20 BY gsyn77 - 将内容填充动作放到动画效果之后是为了解决Firefox
                //	处理Table+Float上的渲染Bug
                echo = X.$(ELEMENT_ID_WIDGET_ECHO);
                echo[TAG_ATTRIBUTE_INNERHTML] += msg;
                scrollIntoBottom(echo); // echo.scrollTop = echo.scrollHeight; 
                /**
                 * fixes #236 - 当初始对话框内容过多时，自动切换到最大化对话框
                 */
                var cu = Wc.ac(PROPERTY_USER_STATE);
                if (echo.scrollHeight && echo.scrollHeight > 450 && STATE_WINDOW == 1 && (cu == 'C' || cu == 'CX')) 
                {
                    W.UST(CMD_MAX)();
                }
                else 
                {
                    try 
                    {
                        X.$(ELEMENT_ID_WIDGET_MSG_INPUT).focus(); // 回显后台消息后将焦点置于输入控件上
                    } 
                    catch (e) 
                    {
                        X.LOG(e);
                    }
                }
            }
            /**
             * 控制消息显示界面
             */
            function displayMsg()
            {
                hm = Wc.ac(PROPERTY_CHATMSG_HISTORY);
                if (X.isVS(hm)) 
                {
                    msg = hm + msg;
                    Wc.rm(PROPERTY_CHATMSG_HISTORY);
                }
                try 
                {
                    Ui[CMD_SHOW_NAMECARD]();
                    if (Wc.ac(PROPERTY_IS_LIST)) 
                    {
                        // 2009-04-28 modified by gsyn77 - 对话历史不滑出显示
                        if (!activeHistory && (STATE_WINDOW == -1 || STATE_WINDOW == 0)) // 如果是‘列表’而且chat-window未拉开
                        {
                            list = X.$(ELEMENT_ID_WIDGET_LIST);
                            widget = X.$(ELEMENT_ID_WIDGET);
                            anchorWrapper = X.$(ELEMENT_ID_WIDGET_ANCHOR_WRAPPER);
                            WIDTH_WIDGET_CURRENT = (WIDTH_WIDGET_CURRENT == STYLE_VALUE_AUTO || WIDTH_WIDGET_CURRENT <= WIDTH_WIDGET_CANVAS) ? WIDTH_WIDGET_CANVAS : WIDTH_WIDGET_CURRENT;
                            HEIGHT_WIDGET_CURRENT = (HEIGHT_WIDGET_CURRENT == STYLE_VALUE_AUTO || HEIGHT_WIDGET_CURRENT <= HEIGHT_WIDGET_CANVAS) ? HEIGHT_WIDGET_CANVAS : HEIGHT_WIDGET_CURRENT;
                            // 收缩widget，展开list
                            FUNCTION_NAME_SLIDER(1, widget, WIDTH_WIDGET_CURRENT, HEIGHT_WIDGET_CURRENT, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                            {
                                if (FUNCTION_NAME_SLIDE_INOUT(ELEMENT_ID_WIDGET_ANCHOR_WRAPPER) == -1) 
                                {
                                    FUNCTION_NAME_SLIDER(-1, anchorWrapper, WIDTH_WIDGET_ANCHOR, HEIGHT_WIDGET_ANCHOR, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                                    {
                                        //HackFirefoxLayoutEngine(-1);
                                    });
                                }
                                if (FUNCTION_NAME_SLIDE_INOUT(list) == -1) 
                                {
                                    FUNCTION_NAME_SLIDER(-1, list, WIDTH_WIDGET_LIST, HEIGHT_WIDGET_LIST, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                                    {
                                        //HackFirefoxLayoutEngine2(WIDTH_WIDGET_CURRENT);
                                    });
                                }
                                showContent();
                                bindKey();
                                STATE_WINDOW = 1;
                            });
                        }
                        else 
                        {
                            showContent();
                        }
                    }
                    else 
                    {
                    
                        if (FUNCTION_NAME_SLIDE_INOUT(ELEMENT_ID_WIDGET) == 1) 
                        {
                            FUNCTION_NAME_SLIDER_TRIGGER(function()
                            {
                                showContent();
                                bindKey();
                                STATE_WINDOW = 1;
                            });
                        }
                        else 
                        {
                            showContent();
                        }
                        
                    }
                    
                    // 暂时取消设置浏览器window焦点
                    // window.focus();
                } 
                catch (e) 
                {
                    X.LOG(e);
                }
            }
            
            store = X.isVS(args.body) ? args : (args.store ? args.store : args);
            /*
             * BUGFIXED:
             * 	firefox 3+ 执行 regex 判断时会出现Bug - 如第一次执行为true，第二次为false
             * 使用indexOf进行补充判断以解决 FireFox 3+ regex 执行 Bug
             */
            if (/(.*)\/history/gi.test(args.from) || X.contains(args.from, '/history')) 
            {
                tb = ELEMENT_CLASS_MSG_SYS;
                if (X.isES(store.subject)) 
                {
                    // 对话历史如下
                    subject = UEC(LANG_CHAT_HISTORY);
                }
                else 
                {
                    subject = UEC(store.subject);
                }
                // RULE-CHANGE: 后台退出对话也显示‘对话历史’
                if (args.state) // && (/active/gi.test(args.state) || X.contains(args.state, 'active'))) 
                {
                    activeHistory = true;
                }
            }
            else 
            {
                // 张三(客服) 19:40:30
                subject = X.format(subjectF, UEC(store.subject), X.isVS(namecard.i1) ? '(' + UEC(namecard.i1) + ')' : '', X.Time());
                
                if (/(.*)\/txt/gi.test(args.from) || X.contains(args.from, '/txt')) 
                {
                    tb = ELEMENT_CLASS_MSG_BACKENDS;
					/**
                     * Flash File Upload (since 2009-06-22) - #242
                     */
                    try {
                        Wi.FuInv(1); // 对话中显示Flash上传
                    } 
                    catch (e) {
                        X.LOG(e);
                    }
                }
                if (/(.*)\/sms/gi.test(args.from) || X.contains(args.from, '/sms')) 
                {
                    tb = ELEMENT_CLASS_MSG_XMS;
                }
                if (/(.*)\/sys/gi.test(args.from) || X.contains(args.from, '/sys')) 
                {
                    tb = ELEMENT_CLASS_MSG_SYS;
                    subject = UEC(store.subject);
                }
            }
            
            if (X.isVS(store.body)) 
            {
                msg = X.format(bodyF, tb, subject, UEC(store.body).replace('|*|', '<br/>').replace(/&amp#34;/gi,'\''), idiv);//add by 罗标新 2009-10-13，把后台 发过来的链接 转义符 &amp#34; 还原成 单引号 “’”
                if (activeHistory) // 如果是‘对话历史’消息，即刚进入新页面时
                {
                    if (!X.isO(echo) || UI_ATWHERE == 1) // 
                    {
                        Wc.ac(PROPERTY_CHATMSG_HISTORY, msg);
                        msg = EMPTY;
                        /*
                         * 后台未退出对话，之前有过对话历史，切换页面之后需要首先显示对话历史
                         */
                        TASKLIST_BEFORE_CUSTOM_PROCEDURE.push(displayMsg);
                    }
                    else if (X.isO(echo)) 
                    {
                        displayMsg();
                    }
                }
                else 
                {
                    displayMsg();
                }
            }
            if (presence && args.state) 
            {
                if (!(/active/gi.test(args.state) || X.contains(args.state, 'active'))) 
                {
                    pres = EMPTY;
                    if (/composing/gi.test(args.state) || X.contains(args.state, 'composing')) 
                    {
                        // 对方正在输入文字……
                        pres = UEC(LANG_PRESENCE_COMPOSING);
                        // 加入延时条件 - 3秒钟后自动清除presence显示的‘对方正在输入文字……’
                        timeoutH = X.at(function()
                        {
                            presence[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
                            X.atc(timeoutH);
                        }, 3000);
                    }
                    if (/gone/gi.test(args.state) || X.contains(args.state, 'gone')) 
                    {
                        // 对方已经退出对话。
                        pres = UEC(LANG_PRESENCE_GONE);
                        /*
                         * IMPORTANT: 处理后台退出对话事件触发
                         */
                        // 首先隐藏并清理名片
                        Ui[CMD_CLEAR_NAMECARD]();
                        // 触发Wc的‘cancel’事件，表示对话结束
                        W.T(CMD_CANCEL);
                        
						/**
	                     * Flash File Upload (since 2009-06-22) - #242
	                     */
	                    try {
	                        Wi.FuInv(0); // 对话中显示Flash上传
	                    } 
	                    catch (e) {
	                        X.LOG(e);
	                    }
						
                        /**
                         * BUGFIX - 提示後臺退出不應當消失（或較長時間後消失） - 2009-06-27 by gsyn77
                         */
                        /*
                         timeoutH = X.at(function(){
                         presence[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
                         X.atc(timeoutH);
                         }, 3000);
                         */
                    }
                    presence[TAG_ATTRIBUTE_INNERHTML] = X.format(presenceF, tp, pres);
                    
                    Wc.B.SM(pres); // 2009-06-11 by gsyn77 #264
                }
            }
            
        };
        /**
         * 负责显示‘人员列表’界面
         * @param {Object} args
         */
        /**
 * 负责显示‘人员列表’界面
 * @param {Object} args
 * @history
 * 	2009-06-03 refs #258
 */
Ui[CMD_SHOW_LIST] = function(args)
{
    // 如果列表界面ui不存在，直接返回
    if (!X.isO(X.$(ELEMENT_ID_WIDGET_LIST)) && (UI_WM_POP && Wi.WM == UI_WM_POP)) 
    {
        return;
    }
    // 如果没有输入参数，那么表示需要读取并显示缓存中的列表HTML-data
    if (!X.isO(args)) 
    {
        try 
        {
            // ELEMENT_ID_WIDGET_LIST 是列表容器
            if (X.$(ELEMENT_ID_WIDGET_LIST)) 
            {
                // ELEMENT_ID_WIDGET_LIST_ITEMS 是列表循环的容器
                X.$(ELEMENT_ID_WIDGET_LIST_ITEMS)[TAG_ATTRIBUTE_INNERHTML] = Wc.ac(PROPERTY_LISTDATA);
            }
        } 
        catch (e) 
        {
            X.LOG(e);
        }
        return;
    }
    
    args = args.store;
    var gboxs = "<table width=\"100%\" cellpadding=\"0\" cellspacing=\"0\" border=\"0\"><tr><td align=\"center\">", gboxe = "</td></tr></table>",    /**
     * %1 - images/card_bg2.gif,images/card_bg.gif
     * %2 - group title
     * %3 - group title abbrev.
     * %4 - group items innerHTML
     */
    gtitle = "<table width=\"100%\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" ><tr><td height=\"25\" background=\"%1\" align=\"left\" class=\"font_title2\" title=\"%2\">&nbsp;%3</td></tr>%4</table>",    /**
     * %1 - on/off line image src
     * %2 - javascript function to show chat window
     * %3 - employee name
     * %4 - employee name abbrev.
     * %5 - icons innerHTML
     */
    glistItem = "<table width=\"94%\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td height=\"19\" width=\"16\" align=\"left\"><img src=\"%1\" width=\"14\" height=\"16\" /></td><td align=\"left\" class=\"font_content\"><a href=\"javascript:void(0);\" onclick=\"%2\" title=\"%3\">%4</a></td><td width=\"50\" align=\"right\">%5</td></tr></table>",    /**
     * %1 - left border image
     * %2 - icons to show
     * %3 - right border image
     */
    glistIcons = "<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td width=\"3\"><img src=\"%1\" width=\"3\" height=\"12\"></td><td align=\"left\">%2</td><td width=\"3\"><img src=\"%3\" width=\"3\" height=\"12\"></td></tr></table>",    /**
     * %1 - javascript function
     * %2 - icon image src
     * %3 - icon title
     */
    giconXTel = "<a href=\"javascript:void(0);\" onclick=\"%1\"><img src=\"%2\" width=\"17\" height=\"12\" border=\"0\" title=\"%3\"></a>", giconXChat = "<a href=\"javascript:void(0);\" onclick=\"%1\"><img src=\"%2\" width=\"25\" height=\"12\" border=\"0\" title=\"%3\"></a>", giconXNote = "<a href=\"javascript:void(0);\" onclick=\"%1\"><img src=\"%2\" width=\"25\" height=\"12\" border=\"0\" title=\"%3\"></a>", giconXXms = "<a href=\"javascript:void(0);\" onclick=\"%1\"><img src=\"%2\" width=\"25\" height=\"12\" border=\"0\" title=\"%3\"></a>", giconXml, imgbase = Ui.imagebase, gsize = args.length, xML = [], 
	giconTitles = ['/images/card_bg.gif', '/images/card_bg2.gif'], 
	giconTitle, 
	giconLines = ['/images/image_offline.gif', '/images/image_online.gif', '/images/image_shouji.gif'], 
	giconLine, 
	giconBorders = ['/images/image_link_liuyan_r1_c1.gif', '/images/image_link_liuyan_r1_c5.gif'], 
	giconChat = '/images/image_link_talk.gif', 
	giconNote = '/images/image_link_liuyan_r1_c4.gif', 
	giconTel = '/images/image_link_liuyan_r1_c2.gif', 
	giconXms = '/images/image_link_duanxin.gif', 
	txMl = [], 
	i, j, zh, gname, gnameshort, gmember, 
	msize, mname, mnameshort, mid, mstate, maddon, 
	jsShowChat, jsShowCall, jsShowNote, param, listbox;
    
    if (gsize < 1) // 如果列表内容为空，直接返回
    {
        return;
    }
    xML.push(gboxs);
    for (i = 0; i < gsize; i++) 
    {
        zh = X.isZH(args[i].name); // 判断是否中文
        gname = args[i].name ? UEC(args[i].name) : EMPTY; // 分组名称
        trunclen = 12;
        gnameshort = gname.length > trunclen ? X.TC(gname, trunclen) + LANG_MULTI_DOTS : gname;
        gmember = args[i].members;
        msize = gmember.length;
        if (!zh) 
        {
            trunclen *= 2;
        }
        giconTitle = imgbase + (i == 0 ? giconTitles[0] : giconTitles[1]);
        
        for (j = 0; j < msize; j++) 
        {
            mname = UEC(gmember[j].name); // 组成员姓名
            zh = X.isZH(gmember[j].name); // 判断是否中文
            trunclen = 4;
            if (!zh) 
            {
                trunclen *= 2;
            }
            mnameshort = mname.length > trunclen ? X.TC(mname, trunclen) + LANG_MULTI_DOTS : mname, mid = gmember[j].id; // 组成员id
            mstate = parseInt(gmember[j].state); // 组成员状态（1：在线；0：离线）
            
            /**
             * refs #258
             */
            maddon = parseInt(gmember[j].addons); // 组成员增值服务情况（电话、短信）： 1 - 短信，3 - 电话，5 - 短信 && 电话
            // on/off-line or cellphone icon src
            giconLine = imgbase + (mstate == 1 || maddon == 0 || maddon == 2 || maddon == 3
				? giconLines[mstate] : giconLines[2]);
            
            jsShowChat = "Ui['" + CMD_SHOW_CHAT + "'](%1);";
            jsShowCall = "Ui['" + CMD_SHOW_CALL + "'](%1);";
            jsShowNote = "Ui['" + CMD_SHOW_NOTE + "'](%1);"
            param = "'" + mid.toString() + "','" + mstate.toString() + "','" + maddon.toString() + "'";
            jsShowChat = X.format(jsShowChat, param);
            jsShowCall = X.format(jsShowCall, param);
            jsShowNote = X.format(jsShowNote, param);
			
            /**
             * refs #258
             */
            giconXml = maddon == 2 || maddon == 3 || maddon == 5 ? 
				X.format(giconXTel, jsShowCall, imgbase + giconTel, unescape(LANG_ICON_TIP_TEL)) : EMPTY;
			
            if (mstate == 1) 
            {
                giconXml += X.format(giconXChat, jsShowChat, imgbase + giconChat, unescape(LANG_ICON_TIP_CHAT));
            }
            else 
            {
                /**
                 * refs #258
                 */
                giconXml += (mstate == 0 && (maddon == 2 || maddon == 1 || maddon == 5)) ? 
					X.format(giconXXms, jsShowChat, imgbase + giconXms, unescape(LANG_ICON_TIP_XMS)) 
					: X.format(giconXNote, jsShowNote, imgbase + giconNote, unescape(LANG_ICON_TOP_NOTE));
            }
            // %5 等待替换
            txMl.push(X.format(glistItem, giconLine, jsShowChat, mname, mnameshort, X.format(glistIcons, imgbase + giconBorders[0], giconXml, imgbase + giconBorders[1])));
            giconXml = EMPTY;
        }
        
        xML.push(X.format(gtitle, giconTitle, gname, gnameshort, txMl.join(EMPTY)));
        txMl = [];
        
    }
    xML.push(gboxe);
    Wc.ac(PROPERTY_LISTDATA, xML.join(EMPTY));
    
    listbox = X.$(ELEMENT_ID_WIDGET_LIST_ITEMS);
    
    if (!X.isO(listbox)) 
    {
        return; // 没有列表注入节点
    }
    else 
    {
        listbox[TAG_ATTRIBUTE_INNERHTML] = Wc.ac(PROPERTY_LISTDATA);
    }
    
};

        /** 
         * 负责显示‘名片’界面
         * @param {Object} args
         */
        Ui[CMD_SHOW_NAMECARD] = function(args)
        {
			// 如果是显示缓存中的namecard数据
            if (!X.isO(args)) 
            {
                args = Wc.ac(CMD_CACHE_NAMECARD); // 看看缓存中是否有namecard数据
                if (!X.isO(args)) 
                {
                    return;
                }
            }
            else 
            {
                args = args.store;
            }
			
            var nc = X.$(ELEMENT_ID_WIDGET_NAMECARD),
			i1 = X.$(ELEMENT_ID_WIDGET_NAMECARD_I1), //部门
			i2 = X.$(ELEMENT_ID_WIDGET_NAMECARD_I2), //姓名
	         i3 = X.$(ELEMENT_ID_WIDGET_NAMECARD_I3), //电话
	         i4 = X.$(ELEMENT_ID_WIDGET_NAMECARD_I4), //邮箱
	         tl = 4, s, em = UEC(LANG_SEND_EMAIL),// ‘发送邮件到：’
	         pm = UEC(LANG_SEND_CALL); // ‘拨打电话：’;
	         
            if (nc) 
            {
                nc[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_BLOCK;
            }
            Wc.ac(CMD_CACHE_NAMECARD, args); // 缓存之
           
		    // 将标题文字修改为 对话人员姓名
			Ui.cTi(args.i2,true);
			
            if (i1) 
            {
                if (!X.isZH(args.i1)) 
                {
                    tl *= 2;
                }
                s = UEC(args.i1);
                
                if (X.isVS(s)) 
                {
                    i1[TAG_ATTRIBUTE_INNERHTML] = s; //'(' + X.TC(s, tl) + '...)';
                    i1.title = s;
                }
                else 
                {
                    i1[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
                }
            }
            if (i2 && args.i2) 
            {
                if (!X.isZH(args.i2)) 
                {
                    tl *= 2;
                }
                s = UEC(args.i2);
                i2[TAG_ATTRIBUTE_INNERHTML] = s; //X.TC(s, tl) + LANG_MULTI_DOTS;
                i2.title = s;
            }
            //电话
            if (i3 && args.i3) 
            {
                if (!X.isZH(args.i3)) 
                {
                    tl *= 2;
                }
                s = UEC(args.i3);
                // 区别大、小对话框并显示电话
                if (i3.tagName.toLowerCase() != TAG_A) 
                {
                    i3[TAG_ATTRIBUTE_INNERHTML] = s; //X.TC(s, tl) + LANG_MULTI_DOTS;
                    i3.title = s;
                }
                else 
                {
                    i3.setAttribute(TAG_ATTRIBUTE_HREF, "javascript:Ui['" + CMD_SHOW_CALL + "']();");
                    i3.title = pm + s;
                }
            }
            //邮箱
            if (i4 && args.i4) 
            {
                if (!X.isZH(args.i4)) 
                {
                    tl *= 2;
                }
                s = UEC(args.i4);
                // 区别大、小对话框并显示电话
                if (i4.tagName.toLowerCase() != TAG_A) 
                {
                    i4[TAG_ATTRIBUTE_INNERHTML] = s; // X.TC(s, tl) + LANG_MULTI_DOTS;
                    i4.title = s;
                }
                else // 如果是链接
                 {
                    i4.setAttribute(TAG_ATTRIBUTE_HREF, 'mailto:' + args.i4);
                    i4.title = em + s;
                }
            }
        };
        /**
         * 负责显示wsdn_widget_expo容器中的‘留下联系方式’界面
         * @param {Object} args
         */
        Ui[CMD_SHOW_CONTACT] = function(args)
        {
        
            if (STATE_WINDOW != 2) 
            {
            
                FUNCTION_NAME_SLIDER_TRIGGER(ELEMENT_ID_WIDGET_CONTACT);
                if (args && args.store) 
                {
                    Ui.echo(args.store.subject, args.store.body);
                }
                
            }
        };	
		/**
		 * 刷新验证码图片
		 */
        Ui.fvcode = function()
        {
            X.at(function()
            {
                /*
                 * 替换验证码image地址
                 */
                try 
                {
                    X.$(ELEMENT_ID_WIDGET_VALIDCODE).src = Ui.authenurl + '?' + X.ticks().toString();
                } 
                catch (e) 
                {
                    X.LOG(e);
                }
            }, 0);
        };
		/**
		 * 用于显示系统提示信息
		 * @param {Object} s - subject
		 * @param {Object} b - body
		 * @param {Object} clazz - 回显消息使用的css class名称
		 */
		Ui.echo = function(s, b, clazz)
		{
			if ( X.isVS(b))
			{
				var tb = clazz ? clazz : ELEMENT_CLASS_MSG_SYS,
				f = LITERAL_FORMAT_ECHO_NORMAL_MSG,
				e = X.$(ELEMENT_ID_WIDGET_ECHO),
				tick = 'chis' + X.ticks().toString(),
				m = X.format(f, tb, UEC(s), UEC(b), tick);
				e[TAG_ATTRIBUTE_INNERHTML] += m;
				scrollIntoBottom(e); // e.scrollTop = e.scrollHeight; 
				try 
				{
				    X.$(ELEMENT_ID_WIDGET_MSG_INPUT).focus(); // 回显后台消息后将焦点置于输入控件上
				} 
				catch (e) 
				{
				    X.LOG(e);
				}
			}
		};
        /**
         * 
         * 根据当前Window状态大小修改标题文字
         * @param {Object} s - 输入的标题文字
         * @param {Object} notChangeListTitle - true，不修改list标题；false，修改list标题
         */
		Ui.cTi = function(s, notChangeListTitle){
			if (!X.isVS(s))
			{
				return;
			}
			var t = X.$(ELEMENT_ID_WIDGET_TITLE),
			lt = X.$(ELEMENT_ID_WIDGET_LIST_TITLE),
			tl = X.isZH(s) ? 4 : 8,			
			ts = UEC(s);
			
			if(X.isO(lt) && !notChangeListTitle)
			{
				lt[TAG_ATTRIBUTE_INNERHTML] = ts.length > tl ? X.TC(ts, tl) + LANG_MULTI_DOTS : X.TC(ts, tl);
				lt.title = ts;
			}
			tl = tl == 4? 8 : 16; // BUGFIXES FOR Firefox IN 2009-04-01: tl = X.isZH(s) ? 8 : 16; // added by gsyn77 in 2009-03-07
			
			// 如果是最大化Window状态
			if (STATE_WINDOW == 2)
			{
				tl *= 2;				
			}
			if (X.isO(t)) 
			{
				t[TAG_ATTRIBUTE_INNERHTML] = ts.length > tl ? X.TC(ts, tl) + LANG_MULTI_DOTS : X.TC(ts, tl);
				t.title = ts;
			}
		};
		/**
         * 负责显示‘留言’界面，并将User-State置为‘TT’（‘未接通并超时’状态）
         * @param {Object} args
         */
        Ui[CMD_SHOW_NOTE] = function(args)
        {
			var popN, id, state, addon, a = arguments;
            /*
             * 将当前User-State状态转为‘T’
             */
            Wc.cu(PROPERTY_VALUE_TT);
			if (STATE_WINDOW != 2) 
			{				                
                
                
                    FUNCTION_NAME_SLIDER_TRIGGER(ELEMENT_ID_WIDGET_NOTE);
				STATE_WINDOW = 1; // 设置当前window为normal-window状态
			}
			else
			{
				popN = X.$(ELEMENT_ID_WIDGET_NOTE_MAX);
				// do popup window to obtain notes
				popN.style.visibility = STYLE_VALUE_VISIBLE;
				popN.style.cursor = STYLE_VALUE_POINTER;
			}
            
            if (a.length == 3) // 如果是‘列表’
            {
                id = a[0]; // employee id
                state = a[1]; // employee state
                addon = a[2]; // employee addon service state
                if (id && state && addon) 
                {
                    Wc.ac(PROPERTY_EID, id); // 『列表专用』
                    Wc.ac(PROPERTY_STATE, state); // 『列表专用』
                	Wc.ac(PROPERTY_ADDON, addon); // 『列表专用』
                }
            }
			if (args && X.isO(args.store)) // 显示留言提示文字
			{
				Ui.echo(args.store.subject, args.store.body);
			}
        };
        /**
         * 负责显示‘电话拨叫’界面
         * @param {Object} id
         * @param {Object} state
         */
        Ui[CMD_SHOW_CALL] = function(id, state, addon)
        {
            STATE_WINDOW = 1; // 设置当前window为normal-chat状态
            if (id && state && addon) 
            {
                Wc.ac(PROPERTY_EID, id); // 『列表专用』
                Wc.ac(PROPERTY_STATE, state); // 『列表专用』
                Wc.ac(PROPERTY_ADDON, addon); // 『列表专用』
            }
            
            
            FUNCTION_NAME_SLIDER_TRIGGER(ELEMENT_ID_WIDGET_CALL);
            // BUGFIXES - 设置验证码图片，以免时间过长导致验证码失效
            Ui.fvcode();
        };
        /**
         * 负责显示‘对话’界面，并将User-State置为‘TC’（请求对话状态）
         * 『列表』 需要传递 employee id 和 employee onlinestate
         * @param {Object} id
         * @param {Object} state
         */
        Ui[CMD_SHOW_CHAT] = function(id, state, addon)
        {
            var widget, aH;
            
            STATE_WINDOW = 1; // 设置当前window为normal-chat状态
            if (id && state && addon) 
            {
                Wc.ac(PROPERTY_EID, id); // 『列表专用』
                Wc.ac(PROPERTY_STATE, state); // 『列表专用』
                Wc.ac(PROPERTY_ADDON, addon); // 『列表专用』
                FUNCTION_NAME_SLIDER_TRIGGER(ELEMENT_ID_WIDGET_LIST);
            }
            else 
            {
            
                FUNCTION_NAME_SLIDER_TRIGGER();
            }
            bindKey();
        };
        /**
         * 将本地缓存消息读取并显示
         */
        Ui[CMD_RESTORE_MSGHISTORY] = function()
        {
            var echo = X.$(ELEMENT_ID_WIDGET_ECHO); // HTML Element: 内容显示
            if (echo) 
            {
                var cachemsg = Wc.cm();
                if (cachemsg) 
                {
                    echo[TAG_ATTRIBUTE_INNERHTML] = cachemsg;
                }
                else 
                {
                    echo[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
                }
            }
        };
        /**
         * 负责缓存对话消息内容
         */
        Ui[CMD_CACHE_MSGHISTORY] = function()
        {
            var echo = X.$(ELEMENT_ID_WIDGET_ECHO); // HTML Element: 内容显示
            if (echo) 
            {
                var msg = echo[TAG_ATTRIBUTE_INNERHTML];
                if (X.isVS(msg)) 
                {
                    Wc.cm(msg);
                }
            }
        };
        /**
         * 负责显示‘邀请对话’界面
         * @param {Object} args
         */
        Ui[CMD_SHOW_INVITE] = function(args)
        {
//            if (args.query != CMD_INVITE) 
//            {
//                return;
//            }
//            
//            // 如果当前处于‘对话’界面而且后台主动发来对话内容，直接显示邀请内容信息    
//            var tb = EMPTY, widget, list, anchorWrapper, a = args.store;
//            if (/(.*)\/sys/gi.test(args.from)) 
//            {
//                tb = ELEMENT_CLASS_MSG_SYS;
//                // 使用<iq query='init'/>中设置的invitestring
//                a.body = UEC(Wc.ac(PROPERTY_INVITATIONS)[0]);
//                // 温馨提示
//                a.subject = UEC(LANG_TIPSTITLE);
//            }
//            
//            if (X.isVS(a.body)) 
//            {                
//				/*
//				 * Since 2009-02-18 by gsyn77: 主动对话邀请直接启动对话流程
//				 */
//                if (/(.*)\/txt/gi.test(args.from)) // Firefox 3.0.6 BUG - 第二次发送的消息不会执行tb赋值
//                {
//                    tb = ELEMENT_CLASS_MSG_BACKENDS;
//                }
//                else if (/(.*)\/sms/gi.test(args.from)) 
//                {
//                    tb = ELEMENT_CLASS_MSG_XMS;
//                }
//                else if (/(.*)\/sys/gi.test(args.from)) 
//                {
//                    Ui.echo(a.subject, UEC(a.body).replace(/(\|\*\|)/gi, '<br/>'), tb);
//                }
				
				/*
				 * COMMENTED BY gsyn77 IN 2009-02-18
				 * 1. 不再使用自动邀请
				 * 2. 主动邀请不做任何处理而只是反向提交一个用户状态TC命令字
				 */
//                if (Wc.ac(PROPERTY_IS_LIST) && (STATE_WINDOW == -1 || STATE_WINDOW == 0)) // 如果是‘列表’而且chat-window未拉开
//                {
//                    widget = X.$(ELEMENT_ID_WIDGET);
//                    list = X.$(ELEMENT_ID_WIDGET_LIST);
//                    anchorWrapper = X.$(ELEMENT_ID_WIDGET_ANCHOR_WRAPPER);
//					WIDTH_WIDGET_CURRENT = WIDTH_WIDGET_CURRENT <= WIDTH_WIDGET_CANVAS ? WIDTH_WIDGET_CANVAS : WIDTH_WIDGET_CURRENT;
//					HEIGHT_WIDGET_CURRENT = HEIGHT_WIDGET_CURRENT <= HEIGHT_WIDGET_CANVAS ? HEIGHT_WIDGET_CANVAS : HEIGHT_WIDGET_CURRENT;
//                    // 收缩widget，展开list
//                    FUNCTION_NAME_SLIDER(1, widget, WIDTH_WIDGET_CURRENT, HEIGHT_WIDGET_CURRENT, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
//                    {
//                        if (FUNCTION_NAME_SLIDE_INOUT(ELEMENT_ID_WIDGET_ANCHOR_WRAPPER) == -1) 
//                        {
//                            FUNCTION_NAME_SLIDER(-1, anchorWrapper, WIDTH_WIDGET_ANCHOR, HEIGHT_WIDGET_ANCHOR, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
//                            {
//                            });
//                        }
//                        if (FUNCTION_NAME_SLIDE_INOUT(list) == -1) 
//                        {
//                            FUNCTION_NAME_SLIDER(-1, list, WIDTH_WIDGET_LIST, HEIGHT_WIDGET_LIST, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
//                            {
//                            });
//                        }                        
//                    });
//                }
//                else 
//                {
//					// 如果没有拉开对话窗口，拉开之
//                    if (FUNCTION_NAME_SLIDE_INOUT(ELEMENT_ID_WIDGET_ANCHOR_WRAPPER) == -1 && (STATE_WINDOW == -1 || STATE_WINDOW == 0)) 
//                    {
//                        FUNCTION_NAME_SLIDER_TRIGGER();
//                    }
//                }
//                window.focus();
//            }
        };
        /**
         * 负责处理通话转接
         * @param {Object} args
         */
        Ui[CMD_SHOW_SWITCHER] = function(args)
        {
            /*
             * 首先清空对话eid及state
             */
            Wc.rm(PROPERTY_EID);
            Wc.rm(PROPERTY_STATE);
			Ui.echo(LANG_TIPSTITLE,LANG_SWITCHCALL);
        };
        /**
         * 负责处理‘留言’返回结果
         * @param {Object} args
         */
        Ui[CMD_SHOW_NOTE_STATE] = function(args)
        {
            if (!X.isO(args)) 
            {
                return;
            }
            // 温馨信息
            var msg = EMPTY;
            if (args.store && parseInt(args.store) == 1) 
            {
                // 留言发送成功
                msg = UEC(LANG_NOTE_SUCCESS);
                Ui[CMD_CLEAR_NOTES]();
                
                // 左右
                try 
                {
                    if (STATE_WINDOW == 2) 
                    {
                        FUNCTION_NAME_SLIDER_TRIGGER(ELEMENT_ID_WIDGET_NOTE); // 留言成功后，隐藏留言面板
                    }
                } 
                catch (e) 
                {
                    X.LOG(e);
                }
                
            }
            else 
            {
                // 留言发送失败
                msg = UEC(LANG_NOTE_FAILURE);
            }
            
            // Show Note submit result tips
            alert(msg);
            Ui.echo(LANG_TIPSTITLE, msg);
        };
        /**
         * 负责清空后台人员‘名片’并隐藏
         */
        Ui[CMD_CLEAR_NAMECARD] = function()
        {
			try {
				var minMode = false;
				for (var i = 1; i < 5; i++) {
					item = X.$(ELEMENT_ID_WIDGET_NAMECARD_ITEM_PREFIX + i.toString());
					item.title = EMPTY;
					if (item.tagName.toLowerCase() == TAG_A) {
						minMode = true;
						item.setAttribute(TAG_ATTRIBUTE_HREF, TAG_VALUE_JSVOID)
						item.onclick = null;
					}
					else {
						item[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
					}
				}
			}catch(e)
			{
				X.LOG(e);
			}
			Wc.rm(CMD_CACHE_NAMECARD);
        };
        /**
         * 负责清空wsdn_echo_msg内容
         */
        Ui[CMD_CLEAR_MSG] = function()
        {
            var echo = X.$(ELEMENT_ID_WIDGET_ECHO);
            if (echo) 
            {
                echo[TAG_ATTRIBUTE_INNERHTML] = EMPTY;
            }
        };
        /**
         * 负责清空输入框
         */
        Ui[CMD_CLEAR_INPUTS] = function()
        {
            var inputs = X.$(ELEMENT_ID_WIDGET_MSG_INPUT);
            if (inputs) 
            {
                inputs.value = EMPTY;
            }
        };
        /**
         * 负责清空‘留言’所有字段
         */
        Ui[CMD_CLEAR_NOTES] = function()
        {        
            if (X.$(ELEMENT_ID_WIDGET_NOTE_NAME)) 
            {
                X.$(ELEMENT_ID_WIDGET_NOTE_NAME).value = EMPTY;
            }
            if (X.$(ELEMENT_ID_WIDGET_NOTE_CORP)) 
            {
                X.$(ELEMENT_ID_WIDGET_NOTE_CORP).value = EMPTY;
            }
            if (X.$(ELEMENT_ID_WIDGET_NOTE_OFFICEPHONE)) 
            {
                X.$(ELEMENT_ID_WIDGET_NOTE_OFFICEPHONE).value = EMPTY;
            }
            if (X.$(ELEMENT_ID_WIDGET_NOTE_OFFICEMAIL)) 
            {
                X.$(ELEMENT_ID_WIDGET_NOTE_OFFICEMAIL).value = EMPTY;
            }
            if (X.$(ELEMENT_ID_WIDGET_NOTE_WEBSITE)) 
            {
                X.$(ELEMENT_ID_WIDGET_NOTE_WEBSITE).value = EMPTY;
            }
            if (X.$(ELEMENT_ID_WIDGET_NOTE_IM)) 
            {
                X.$(ELEMENT_ID_WIDGET_NOTE_IM).value = EMPTY;
            }
            
            if (X.$(ELEMENT_ID_WIDGET_NOTE_MSG)) 
            {
                X.$(ELEMENT_ID_WIDGET_NOTE_MSG).value = EMPTY;
            }
            
        };
		/**
		 * 清空联系方式所有字段
		 */
        Ui[CMD_CLEAR_CONTACT] = function(){
			try {
				if (X.$(ELEMENT_ID_WIDGET_CONTACT_NAME)) {
					X.$(ELEMENT_ID_WIDGET_CONTACT_NAME).value = EMPTY;
				}
				if (X.$(ELEMENT_ID_WIDGET_CONTACT_CORP)) {
					X.$(ELEMENT_ID_WIDGET_CONTACT_CORP).value = EMPTY;
				}
				if (X.$(ELEMENT_ID_WIDGET_CONTACT_OFFICEPHONE)) {
					X.$(ELEMENT_ID_WIDGET_CONTACT_OFFICEPHONE).value = EMPTY;
				}
				if (X.$(ELEMENT_ID_WIDGET_CONTACT_OFFICEMAIL)) {
					X.$(ELEMENT_ID_WIDGET_CONTACT_OFFICEMAIL).value = EMPTY;
				}
				if (X.$(ELEMENT_ID_WIDGET_CONTACT_WEBSITE)) {
					X.$(ELEMENT_ID_WIDGET_CONTACT_WEBSITE).value = EMPTY;
				}
				if (X.$(ELEMENT_ID_WIDGET_CONTACT_IM)) {
					X.$(ELEMENT_ID_WIDGET_CONTACT_IM).value = EMPTY;
				}
			}catch(e)
			{
				X.LOG(e);
			}
		};
		/*************************************************************************************
         * 用户可以使用的Panel事件方法 —— 类似于操纵Windows窗口
         * 	W.UST['min'];		// 最小化
         * 	W.UST['normal'];		// 还原
         * 	W.UST['max'];		// 最大化
         * 	W.UST['pop'];		// 在新的弹出窗口中显示
         * 	W.UST['close'];		// 关闭
         ************************************************************************************/
        
		
		/*********************STAGE 11: 动画特效 *************************/
        /**
         * 动态效果 - 缩放边界
         */
        FUNCTION_NAME_EXPANDO = X.exdo;
        /**
         * 动态效果 - 淡入、淡出
         */
        FUNCTION_NAME_FADE = X.exfa;
		/**
		 * 动态效果 - 滑动伸缩
		 */
		FUNCTION_NAME_SLIDER = X.exsl;
        /**
         * 动态效果判定方法
         */
		FUNCTION_NAME_SLIDE_INOUT = X.exio;
		
		/**
		 * 卷帘 动画效果
		 * @param {Object} el
		 */
        FUNCTION_NAME_SLIDER_TRIGGER = function(el)
        {            
            var a = arguments, fn,
			anchor = X.$(ELEMENT_ID_WIDGET_ANCHOR), 
			anchorP = X.$(ELEMENT_ID_WIDGET_ANCHOR_WRAPPER), 
			expo = X.$(ELEMENT_ID_WIDGET_EXPO),
			widget = X.$(ELEMENT_ID_WIDGET), 
			call = X.$(ELEMENT_ID_WIDGET_CALL),
			contact = X.$(ELEMENT_ID_WIDGET_CONTACT), 
			list = X.$(ELEMENT_ID_WIDGET_LIST),
			note = X.$(ELEMENT_ID_WIDGET_NOTE),
			aio = FUNCTION_NAME_SLIDE_INOUT(anchorP), // anchor in or out
			eio = FUNCTION_NAME_SLIDE_INOUT(expo), // expo in or out
			rW, // 实际widget canvas的width
			rH, // 实际widget canvas的height			
			cel,
			isEventParam, // 当前处理的dom element
			wPos,
			timeoutH,
			panel = X.$(Wc.ac(UI_MODE_NORMAL).id); 
			
            /**
             * 隐藏 wsdn_widget_anchor_wrapper
             */
            function hideAnchor()
            {
                if (anchorP && FUNCTION_NAME_SLIDE_INOUT(anchorP) == -1) 
                {
                    FUNCTION_NAME_SLIDER(-1, anchorP, WIDTH_WIDGET_ANCHOR, HEIGHT_WIDGET_ANCHOR, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                    {
                    
                    });
                }
            }
            /**
             * 隐藏 wsdn_widget_list
             */
            function hideList()
            {
                if (list && FUNCTION_NAME_SLIDE_INOUT(list) == -1) 
                {
                    FUNCTION_NAME_SLIDER(-1, list, WIDTH_WIDGET_LIST, HEIGHT_WIDGET_LIST, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                    {
                    });
                }
            }
			/**
			 * 处理‘列表’伸缩动态效果
			 * @param {Object} lio - 伸缩参数：1，伸展；-1，收缩
			 * @param {Function} callback - Optional 用于串行化
			 */
            function TsList(lio)
            {
                if (X.isO(list)) 
                {
                    var a = arguments, io = X.isO(lio) ? lio : FUNCTION_NAME_SLIDE_INOUT(list);
					if (PIXEL_WIDTH_WIDGET_EXPO != 0 )
					{
						WIDTH_WIDGET_CURRENT = WIDTH_WIDGET_CANVAS + PIXEL_WIDTH_WIDGET_EXPO;
						HEIGHT_WIDGET_CURRENT = HEIGHT_WIDGET_CANVAS;
					}
					WIDTH_WIDGET_CURRENT = ( WIDTH_WIDGET_CURRENT == STYLE_VALUE_AUTO || WIDTH_WIDGET_CURRENT <= WIDTH_WIDGET_CANVAS) ? WIDTH_WIDGET_CANVAS : WIDTH_WIDGET_CURRENT;
					HEIGHT_WIDGET_CURRENT = ( HEIGHT_WIDGET_CURRENT == STYLE_VALUE_AUTO || HEIGHT_WIDGET_CURRENT <= HEIGHT_WIDGET_CANVAS ) ? HEIGHT_WIDGET_CANVAS : HEIGHT_WIDGET_CURRENT;
					
                    // 收缩widget，展开list
					//panel[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = WIDTH_WIDGET_CURRENT.toString() + STYLE_UNIT_PX;
					//HackFirefoxLayoutEngine();
                    FUNCTION_NAME_SLIDER(-io, widget, WIDTH_WIDGET_CURRENT, HEIGHT_WIDGET_CURRENT, 
						SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, 
						function()
                    {
                        FUNCTION_NAME_SLIDER(io, list, WIDTH_WIDGET_LIST, HEIGHT_WIDGET_LIST, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                        {
							if (X.isF(a[1]))
							{
								a[1].apply(this);
							}
							//panel[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = WIDTH_WIDGET_LIST.toString() + STYLE_UNIT_PX;
							//HackFirefoxLayoutEngine(-io);
                        });
                    });
                }
            }
            /**
             * 切换wsdn_widget_expo中的contact、note、telphone，并调整其宽度
             * @param {Object} widgetId
             */
            function toggleExpo(widgetId)
            {
				if (contact) 
				{
					contact[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
				}
				if (note) 
				{
					note[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
				}
				if (call) 
				{
					call[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
				}
				if (!X.isVS(widgetId))
				{
					return;
				}
				
				var tw = X.$(widgetId),cWidth;
				if (tw)
				{
					tw[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_BLOCK;
					PIXEL_WIDTH_WIDGET_EXPO = WIDTH_WIDGET_CALL;
					PIXEL_HEIGHT_WIDGET_EXPO = HEIGHT_WIDGET_CALL;
					cWidth = PIXEL_WIDTH_WIDGET_EXPO + WIDTH_WIDGET_CANVAS;
				}
				/**
				 * 展开 wsdn_widget_expo
				 */
                function expandExpo()
				{
					if (FUNCTION_NAME_SLIDE_INOUT(expo) == 1) 
                        {
                            FUNCTION_NAME_SLIDER(1, expo, PIXEL_WIDTH_WIDGET_EXPO, PIXEL_HEIGHT_WIDGET_EXPO, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                            {
                                widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = cWidth.toString() + STYLE_UNIT_PX;
								//HackFirefoxLayoutEngine2(cWidth);
                                hideList();
                            });
                        }
				}
                if (FUNCTION_NAME_SLIDE_INOUT(widget) == 1) 
                {
					//HackFirefoxLayoutEngine2(cWidth + WIDTH_WIDGET_LIST);
                    FUNCTION_NAME_SLIDER(1, widget, cWidth, (HEIGHT_WIDGET_CANVAS), SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                    {
                        expandExpo();
                    });
                }
                else 
                {
                    expandExpo();
                }
                hideAnchor();
            }
			
			try
			{
				isEventParam = el.constructor && el.constructor == MouseEvent;
			}
			catch(e)
			{
				isEventParam = false;
			}
			
			if (!(X.msie || X.ff)) 
			{
				toggleExpo(); // BUG - 2009-03-02 BY gsyn77 解决Google、Safari浏览器显示兼容性问题
			}
			
			/**
			 * 判断是否用于动态显示‘电话’、‘留言’
			 * BUGFIXED: 2009-02-20 BY gsyn77 
			 * 	- Firefox 会自动将mouseover的MouseEvent事件作为参数传入，要排除这种情况
			 */
			if (X.isO(el) && !isEventParam && !X.isF(el))
			{
				if(X.isVS(el)) // 如果传入的是id字符串，将其转化为object
				{
					el = X.$(el);
				}
                if (el.id == ELEMENT_ID_WIDGET_LIST) // 如果当前是‘列表’
				{                    
                    TsList();
				}
				else
				{
					toggleExpo(el.id);
				}
				
				WIDTH_WIDGET_CURRENT = parseInt(widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH]);
				HEIGHT_WIDGET_CURRENT = parseInt(widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT]);
				//BUGFIXED: 2009-02-21 BY gsyn77 - 
				//	预防 dom element 的 style.height 或 style.width 属性为 'auto' 或其他不能转化为数字的值
				WIDTH_WIDGET_CURRENT =  isNaN(WIDTH_WIDGET_CURRENT) ? widget.clientWidth || widget.offsetWidth : WIDTH_WIDGET_CURRENT;
				HEIGHT_WIDGET_CURRENT = isNaN(HEIGHT_WIDGET_CURRENT) ? widget.clientHeight || widget.offsetHeight : HEIGHT_WIDGET_CURRENT;
				widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = WIDTH_WIDGET_CURRENT.toString() + STYLE_UNIT_PX;
				widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT] = HEIGHT_WIDGET_CURRENT.toString() + STYLE_UNIT_PX;
				
				return;
			}
			
            /*
             *	只有展开window才会触发下面的流程
              */
            // 注销原有事件
			AnchorEvent(0);
            if (STATE_WINDOW_SLIDING == 0) 
            {
                return;
            }
            if (STATE_WINDOW_SLIDING != 0) 
            {
                STATE_WINDOW_SLIDING = 0;
            }
            
			
			if (STATE_WINDOW < 1 )		// 拉开 widget-window
			{
				if ( WINDOW_STATE_HISTORY.length > 0 ) // 如果是要恢复最小化window
				{
					wPos = WINDOW_STATE_HISTORY.pop();
					WIDTH_WIDGET_CURRENT = rW = wPos.w; 
					HEIGHT_WIDGET_CURRENT = rH = wPos.h; 
					cel = wPos.el;
					STATE_WINDOW = wPos.ws;
				}
				else if (Wc.ac(PROPERTY_IS_LIST) )
				{
					rW = WIDTH_WIDGET_LIST;
					rH = HEIGHT_WIDGET_LIST;
					cel = list;
				}
				else
				{
					WIDTH_WIDGET_CURRENT = rW = WIDTH_WIDGET_CANVAS;
					HEIGHT_WIDGET_CURRENT = rH = HEIGHT_WIDGET_CANVAS;
					cel = widget;
				}
			}
			else if (STATE_WINDOW > 0 )	// 隐藏 widget-window
			{
			}
			// 检查是否输入了callback
			fn = X.isF(el) ? el : X.isF(a[1]) ? a[1] : null;
            // slide out - show
            switch (aio)
            {
                case 1:
                {					
					/*
					 *  FIXME:
					 *  - FireFox不能自动扩展容器Panel(wsdn_panel_xx)的宽度，所以导致界面错位；可以通过动态设定容器Panel宽度方式来解决这一问题
					 *  - 候选方法有两个：
					 *  -	1. 使用最大width——无论怎么伸展界面都不会超过，只在动画结束时将容器Panel width设为当前容器内所有Controls' width大小之和；
					 *  -	2. 无论伸展还是收缩，都是用精确的容器Panel预期width。
					 */
					//panel[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = (WIDTH_WIDGET_ANCHOR + rW).toString() + STYLE_UNIT_PX;
					//HackFirefoxLayoutEngine();
                    timeoutH = X.at(function()
                    {
                        FUNCTION_NAME_SLIDER(aio, anchorP, WIDTH_WIDGET_ANCHOR, HEIGHT_WIDGET_ANCHOR, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                        {
                            FUNCTION_NAME_SLIDER(-1, cel, rW, rH, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                            {
                                STATE_WINDOW_SLIDING = 1;
								AnchorEvent();
								if (fn)
								{
									fn.apply(this);
								}
								//panel[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = (WIDTH_WIDGET_ANCHOR).toString() + STYLE_UNIT_PX;
								//HackFirefoxLayoutEngine(-aio);
								X.atc(timeoutH);
                            });
                        })
                    }, 100);
                    break;
                    
                }
                case -1:
                {
					//panel[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = (WIDTH_WIDGET_ANCHOR + rW).toString() + STYLE_UNIT_PX;
					//HackFirefoxLayoutEngine();
                    timeoutH = X.at(function()
                    {
                        FUNCTION_NAME_SLIDER(1, cel, rW, rH, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                        {
							if (cel == widget)
							{
								bindKey();
							}
                            FUNCTION_NAME_SLIDER(aio, anchorP, WIDTH_WIDGET_ANCHOR, HEIGHT_WIDGET_ANCHOR, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
                            {
                                STATE_WINDOW_SLIDING = 1;
                                // 重新注册事件
								AnchorEvent();
								if (fn)
								{
									fn.apply(this);
								}
								
								//panel[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = rW.toString() + STYLE_UNIT_PX;
								//HackFirefoxLayoutEngine(-aio);
								
								X.atc(timeoutH);
                            });
                        })
                    }, 100);
                    break;
                }
            }
        };
		/**
         * 只用于隐藏wsdn_widget_expo
         * 
         * @param {Object} lio
         * @param {Object} fn
         */
        FUNCTION_NAME_EXPO_SLIDER_TRIGGER = function(lio, fn)
        {
            var widget = X.$(ELEMENT_ID_WIDGET), 
			expo = X.$(ELEMENT_ID_WIDGET_EXPO),
			call = X.$(ELEMENT_ID_WIDGET_CALL),
			contact = X.$(ELEMENT_ID_WIDGET_CONTACT), 
			note = X.$(ELEMENT_ID_WIDGET_NOTE), 
			eio = FUNCTION_NAME_SLIDE_INOUT(expo);
			if (lio && lio != eio ) // 如果指定动作与预期动作相同，直接返回不做处理
			{
				 if (fn) {fn.apply(this);}
				 return;
			}
			if (expo && eio == -1) 
			{
				FUNCTION_NAME_SLIDER(eio, expo, WIDTH_WIDGET_CALL, HEIGHT_WIDGET_CALL, SLIDER_DIRECTION_CURRENT, TIMER_STEP_SLIDER, function()
				{
					PIXEL_WIDTH_WIDGET_EXPO = (eio == 1 ? WIDTH_WIDGET_CALL : 0); // 设置widget_expo的当前状态：展开、折叠

					// BUGFIXED - 2009-03-02 BY gsyn77 解决Google、Safari浏览器显示兼容性问题
                    contact[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
                    note[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
                    call[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_DISPLAY] = STYLE_VALUE_NONE;
					
					widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = (eio == 1 ? (WIDTH_WIDGET_CALL + WIDTH_WIDGET_CANVAS).toString() + STYLE_UNIT_PX : WIDTH_WIDGET_CANVAS.toString() + STYLE_UNIT_PX);
					WIDTH_WIDGET_CURRENT = parseInt(widget[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH]);
					if (fn) 
					{
						fn.apply(this);
					}
				});
			}
        };
        /**
         * 保存对话历史记录
         */
        FUNCTION_NAME_SAVE_CHATHISTORY = function()
        {
            try 
            {
                var sChatInformation = X.$(ELEMENT_ID_WIDGET_ECHO)[TAG_ATTRIBUTE_INNERHTML], 
				objSave = popW('about:blank','Wsdn_Save_ChatMsg',200,200,400,350);
                objSave.document.write(sChatInformation);
				objSave.document.close();
				
                if (X.msie)
                {
					// BUGFIXES in 2009-04-08 by gsyn77: execCommand('save') 方法如果不立即保存，则会导致与服务器之间的连接中断
                //	objSave.document.execCommand('SaveAs', '', 'Chat.html');
				//	objSave.close();
                }				                
            } 
            catch (e) 
            {
                X.LOG(e);
            }
        };
		/*********************STAGE 12: 开始加载界面处理*************************/
        Ui.Ts = FUNCTION_NAME_SLIDER_TRIGGER;
        Ui.Es = FUNCTION_NAME_EXPO_SLIDER_TRIGGER;		
		Ui.sCH = FUNCTION_NAME_SAVE_CHATHISTORY;
		
		/**
		 * INCLUDE: 使用Flash Cookie启动
		 * Since 2009-05-12
		 */        
        if (X.FlashEnabled()) {
            
/**************************#242**********************************
 * @overview Flash File Upload (since 2009-05-21) - #242
 * @author gsyn77
 * @version 1.0
 * @history
 ***************************************************************/

/**************************Flash AutoPop**********************************
 * @overview Flash AutoPop
 * @author gsyn77
 * @version 1.0
 * @history
 ***************************************************************/

//弹出窗口 邀请flash
Ui._wsdn_fp_name = 'wsdn_liveFp';

//弹出窗口 Flash 交互函数
window.wsdn_liveFp_DoFSCommand = function (command, args){
    Wi.FlashProxy(command,args);
    };        

//显示邀请
 Wi.Fp=function(){
    	var _wsdn_fp_name = Ui._wsdn_fp_name,  root = X.msie ? window : window.document;		
		var PROPERTY_IP="Ip";
		var _wsdn_fp_Msg=B[PROPERTY_AUTOPOP_MSG];
		
		var _wsdn_fp_Ip=B[PROPERTY_IP];
		if(_wsdn_fp_Msg)
		{
			if(_wsdn_fp_Msg != "")
			{
				try
		    	{
		    	root[_wsdn_fp_name].SetVariable("_wsdn_AutoPop.$Ip", [_wsdn_fp_Ip,"的朋友!"].join(""));		
				root[_wsdn_fp_name].SetVariable("_wsdn_AutoPop.$Msg", _wsdn_fp_Msg);
				root[_wsdn_fp_name].SetVariable("_wsdn_AutoPop.$showMovie", "true");		
				}
				catch(ex)
				{
					X.LOG(ex);
				}		
			}
		}
    		
    }
  

// 接受邀请
   Wi.Fpa=function(){ 
      Ui['showchat']();
      W.UST('close');
    }
 // 拒绝邀请
    Wi.Fpr=function(){     
      W.UST('close');
    }
	

// 設置上傳Flash根地址
if (!X.isO(Ui.livefurl)) {
    Ui.livefurl = '';
}
// 設置文件上傳服務地址
if (!X.isO(Ui.livefcurl)) {
    Ui.livefcurl = '';
}
// 設置文件上傳彈出窗口服務地址
if (!X.isO(Ui.livefcwurl)) {
    Ui.livefcwurl = '';
}
Ui._wsdn_fu_name = 'wsdn_liveFu';
/**
 * 上傳Flash交互函數
 * @param {Object} command
 * @param {Object} args
 */
window.wsdn_liveFu_DoFSCommand = function (command, args){
    Wi.FlashProxy(command,args);
};
/**
 * 页面内即时通讯状态下Flash文件上传弹出窗口
 */
Wi.FuW = function(){
    var url = [Ui.livefwurl, '?w=', Wc.ac('wsid'), '&s=', Wc.ac('sid')].join(''), name = 'Wsdn_LiveFuW';
    Wi.$FuW = X.newWin(url, name, 200, 200, 320, 320); // url, name, feature, replace, callback
};
/**
 * 【文件上传服务】 页面LiveFUx.aspx中使用
 * 由上传Flash调用用于初始化上传参数
 */
Wi.Fu = function(){
    var _wsdn_fu_name = Ui._wsdn_fu_name, root = X.msie ? window : window.document;
	try {
		// 设置上传服务地址 - 上傳服務地址必須與Flash來源地址保持一直，即來自同一域名
		root[_wsdn_fu_name].SetVariable('_wsdn_wsfu.uri', Ui.livefcurl);
		// 當前客戶站點Id
		root[_wsdn_fu_name].SetVariable('_wsdn_wsfu.w', Wc.ac('wsid'));
		// 當前訪客Id
		root[_wsdn_fu_name].SetVariable('_wsdn_wsfu.s', Wc.ac('sid'));
		// 設置可以上傳文件類型： 1 - 只能上傳壓縮文件（*.zip或*.rar）；0 - 除了壓縮文件外，可以上傳所有文件（*.*）
		root[_wsdn_fu_name].SetVariable('_wsdn_wsfu.a', '1');
		// 0 - 前台上传文件；1 - 后台上传文件
		root[_wsdn_fu_name].SetVariable('_wsdn_wsfu.t', '0');
	}catch(ex)
    {
		X.LOG(ex);
	}
};
/**
 * 显示或隐藏文件上传Flash
 * @param {Object} invisible - 0, invisible; 1, visible;
 */
Wi.FuInv = function(invisible){
    var _wsdn_fu_name = Ui._wsdn_fu_name, root = X.msie ? window : window.document;
	try {
		root[_wsdn_fu_name].SetVariable('_wsdn_wsfu.ut', invisible);
	}catch(ex)
	{
		X.LOG(ex);
	}
};
/**
 * 【文件上传服务】 页面LiveFUx.aspx中使用
 * 处理上传文件事件
 * @param {Object} m
 * @param {Object} n
 */
Wi.Fue = function(m, n){
    var sTipsTitle = UEC(LANG_TIPSTITLE); // 温馨提示
    switch (m.toLowerCase()) {
		case 'onChoose': // 用戶點擊FlashUpload按鈕
			Wc.ac(PROPERTY_GUARD,1); // #283 - 设定当前用户处于选择（上传）文件开始阶段
			break;
		case 'onSelect' : // 用戶已經選擇需上傳的文件
			Wc.ac(PROPERTY_GUARD,0); // #283 - 设定当前用户处于选择（上传）文件结束阶段
			break;
        case 'oncomplete':
			var sComplete = [sTipsTitle, '：',UEC(LANG_LIVEFU_FILE), n, UEC(LANG_LIVEFU_TRANSFORCOMPLETE)].join('');
            alert(sComplete);
			try
			{
				Ui[CMD_ECHO_MSG](sComplete,'no'); // for base/controller.js use only
			}catch(e)
			{
				X.LOG(e);
			}
            Wi.Fuc(ESC(n));
            break;
		case 'onSizeError':
			if (!X.isO(W.fsize))
			{
				W.fsize = 4;
			}
			alert([sTipsTitle,UEC(LANG_LIVEFU_FILE), '：', n, UEC(LANG_ERROR_FILESIZE),W.fsize,'Mb'].join(''))
			break;
		case 'onchat':
			// 只有对话中才能上传文件
			if ( n == '0' || n == 0 ) alert([sTipsTitle, '：', UEC(LANG_ERROR_NOCHAT_NOUPLOAD)].join('')); 
			break;
        case 'openerror':
            alert([sTipsTitle, '：', UEC(LANG_ERROR_OPENFILEDIALOG)].join(''));
            break;
        case 'ioerror':
            alert([sTipsTitle, '：', UEC(LANG_ERROR_OPENFILE)].join(''));
            break;
        case 'httperror':
            alert([sTipsTitle, '：', UEC(LANG_ERROR_HTTP)].join(''));
            break;
        case 'securityerror':
            alert([sTipsTitle, '：', UEC(LANG_ERROR_NOUPLOAD_AUTHORITY)].join(''));
            break;
    }
};
/**
 * 当文件上传完毕后，将上传文件信息发送给后台
 * @param {Object} n
 */
Wi.Fuc = function(n){
    if (X.isVS(n)) {
        W.T(CMD_PUSH, '_fxu_', n);
    }
};

/**************************************#149************************************************
 * 2009-05-14 by gsyn77 - #149
 *
 * 【FSO内置变量】
 * 变量名：_wsdn_wsfc
 *
 * 【FSO命令】
 * '$uecp' - READ：读取所有FSO内容（逗号分隔的Key=Value）； WRITE：触发存储【FSO内置变量】的所有属性值；
 * '$uecs' - READ-ONLY：获取当前FSO实际存储大小；
 * '$uecc' - WRITE-ONLY：清空当前FSO所有内容；
 * '$bingo' - WRITE-ONLY：直接获取指定属性在FSO中的值，FlashObject將回調Wc.ac(k,v)傳遞k的值給v；
 * '$gotcha' - WRITE-ONLY：直接獲取FSO中所有屬性的值並作為Json返回；FlashObject將回調W.Fxro(json)以傳入json結果；
 *
 * 【FSO默认序列化条目】 条目名称中的'*'由实际客户站点Id替换
 * '_uncsid_*' - 访客Id
 * '_unclvt_*' - 访客上次访问时间
 * '_unccvt_*' - 访客本次访问时间
 * '_uncvct_*' - 访客访问人次
 *
 * 明文：广州资源
 * 密钥：LiveFx
 * 密文： 121,173,23,211,104,22,77,150,99,127,255,18,180,168,102,91
 * 密文(Hex)：79,ad,17,d3,68,16,4d,96,63,7f,ff,12,b4,a8,66,5b
 *****************************************************************************************

var OBJECT_LIVEFX = '_wsdn_wsfc.', //
OBJECT_LIVEFX_SID = PROPERTY_SID, //
OBJECT_LIVEFX_LVT = '_lvt_', //
OBJECT_LIVEFX_CVT = '_cvt_', //
OBJECT_LIVEFX_VCT = '_vct_', //
CMD_LIVEFX_SAVE = '$uecp', //
CMD_LIVEFX_WRITE = '$toucha', //
CMD_LIVEFX_READ = '$uecp', //
CMD_LIVEFX_SIZE = '$uecs', //
CMD_LIVEFX_CLEAR = '$uecc', //
CMD_LIVEFX_SEARCH = '$bingo', //
CMD_LIVEFX_SEARCHALL = '$gotcha', //
CRYPTO_LIVEFX_KEY_SAVE = '79,ad,17,d3,68,16,4d,96,63,7f,ff,12,b4,a8,66,5b';
*/

/**
 * 获取FSO对象引用
 */
W.Fx = function(){
    if ((X.FlashEnabled()) && Wi.liveFx && Wi.liveFxId) {
        Wi.$liveFx = X.msie ? window[Wi.liveFxId] : document[Wi.liveFxId]; // 获取FlashCookie Object
        return true;
    }
    return false;
};
/**
 * 负责存储FSO
 * @param {Object} sid
 * @param {Object} lvt - last-visit-time
 * @param {Object} cvt - current-visit-time
 * @param {Object} vct - visit-count
 * @return {Boolean} true - saved succesfully, false - otherwise
 */
W.Fxs = function(sid, lvt, cvt, vct){
    if (W.Fx()) {
        var sWsid = Wc.ac(PROPERTY_WSID), bNeedSave = false;
        if (sid) {
            Wi.$liveFx.SetVariable(OBJECT_LIVEFX + OBJECT_LIVEFX_SID, sid); // sid
            bNeedSave = true;
        }
        if (lvt) {
            Wi.$liveFx.SetVariable(OBJECT_LIVEFX + OBJECT_LIVEFX_LVT, lvt); // last-visit-time
            bNeedSave = true;
        }
        if (cvt) {
            Wi.$liveFx.SetVariable(OBJECT_LIVEFX + OBJECT_LIVEFX_CVT, cvt); // current-visit-time
            bNeedSave = true;
        }
        if (vct) {
            Wi.$liveFx.SetVariable(OBJECT_LIVEFX + OBJECT_LIVEFX_VCT, vct); // visit-count
            bNeedSave = true;
        }
        // 存储上面所有属性~值		
        if (bNeedSave) {
            Wi.$liveFx.SetVariable(OBJECT_LIVEFX + CMD_LIVEFX_SAVE, CRYPTO_LIVEFX_KEY_SAVE);
            return true;
        }
    }
    return false;
};
/**
 * 負責將發來的Cookie存儲到FSO中
 * @param {Object} stana
 */
W.Fxso = function(stana){
    if (!X.isO(stana)) {
        return false;
    }
    stana = stana.store;
    if (W.Fx()) {
        var sWsid = Wc.ac(PROPERTY_WSID), bNeedSave = false;
        if (stana.sid) {
            Wi.$liveFx.SetVariable(OBJECT_LIVEFX + OBJECT_LIVEFX_SID, stana.sid); // sid
            bNeedSave = true;
        }
        if (stana.lvt) {
            Wi.$liveFx.SetVariable(OBJECT_LIVEFX + OBJECT_LIVEFX_LVT, stana.lvt); // last-visit-time
            bNeedSave = true;
        }
        if (stana.cvt) {
            Wi.$liveFx.SetVariable(OBJECT_LIVEFX + OBJECT_LIVEFX_CVT, stana.cvt); // current-visit-time
            bNeedSave = true;
        }
        if (stana.vct) {
            Wi.$liveFx.SetVariable(OBJECT_LIVEFX + OBJECT_LIVEFX_VCT, stana.vct); // visit-count
            bNeedSave = true;
        }
        // 存储上面所有属性~值		
        if (bNeedSave) {
            Wi.$liveFx.SetVariable(OBJECT_LIVEFX + CMD_LIVEFX_SAVE, CRYPTO_LIVEFX_KEY_SAVE);
            return true;
        }
    }
    return false;
};
/**
 * 調用 '$bingo' 命令將指定FSO中的屬性k的值讀取到緩存中
 * @param {Object} k - 需要在FSO中查找的屬性名稱
 */
W.Fxrc = function(k){
    if (W.Fx()) {
        Wi.$liveFx.SetVariable([OBJECT_LIVEFX , CMD_LIVEFX_SEARCH].join(''), k);
        return true;
    }
    return false;
};
/**
 * 用來解析W.Fxrc執行後Flash返回的Key~Value
 * @param {Object} json
 */
W.Fxrcp = function(json)
{
	if(json)
	{
		for (var p in json)
		{
			if (p && json.hasOwnProperty(p))
			{
				Wc.ac(p,json[p]);
			}
		}
	}
};
/**
 * 负责存储Json内容到FSO中
 */
W.Fxsc = function(json)
{
	if (W.Fx()) {
        Wi.$liveFx.SetVariable([OBJECT_LIVEFX , CMD_LIVEFX_WRITE].join(''), json);
        return true;
    }
    return false;	
};
/**
 * 用于读、写当前focus或最后打开的弹出窗口id - #279
 * @param {Number} v - 是否将当前弹出窗口id进行重新设置，其值为v；或者用于比较弹出窗口id和输入v值是否相符（当且仅当 b == true）
 * @param {Boolean} b - true：比较当前弹出窗口id和输入v值是否相符
 */
W.Fxcwid = function(v,b){
    if (W.Fx()) {
        var k = [OBJECT_LIVEFX, 'popcwid'].join(''), r;
        if (b || !X.isO(v)) {
            if (X.msie) {
                r = Wi.$liveFx.GetVariable(k);
            }
            else {
                /**
                 * 對於Firefox需要先通過中間命令將FSO的值讀取到Flash內置空間中
                 */
                k = [OBJECT_LIVEFX, '$popcwid'].join('');
                Wi.$liveFx.SetVariable(k, v);
                /**
                 * 然後由Js負責讀取_root對應變量值
                 */
                k = ['_root', 'popcwid'].join('.');
                r = Wi.$liveFx.GetVariable(k);
            }
            if (X.isO(r) && r.toLowerCase() != 'undefined' && r.toLowerCase() != 'null') {
				if (b)
				{
					return r == v;
				}
                return true;
            }
            else {
                return false;
            }
        }
        else {
            Wi.$liveFx.SetVariable(k, v);
        }
    }
};
/**
 * '$gotcha' 命令回調方法 - 負責將所有FSO中屬性~值緩存
 * @param {Object} json - FSO中所有屬性~值的Json字符串
 */
W.Fxro = function(json, fn){
    if (!X.isVS(json)) {
        return false;
    }
    var oJson = new Function('return ' + json)();
    if (X.isO(oJson)) {
        for (var p in oJson) {
            if (oJson.hasOwnProperty(p)) {
                Wc.ac(p, oJson[p]);
            }
        }
    }
    if (X.isF(fn)) {
        fn.apply(this);
    }
    return true;
};
/**
 * 负责读取FSO - LiveFx Object 第1個執行的方法
 */
W.Fxr = function(){
    if (W.Fx()) {
        Wi.$liveFx.SetVariable([OBJECT_LIVEFX , CMD_LIVEFX_SEARCHALL].join(''), CRYPTO_LIVEFX_KEY_SAVE);
        return true;
    }
    return false;
};

/**
 * 用于处理FlashCookie交互的接口函数
 * @param {Object} command
 * @param {Object} args
 */
window.wsdn_liveFx_DoFSCommand = function (command, args){
    Wi.FlashProxy(command,args);
};
/**
 * 處理所有Flash回調事件
 * @param {Object} command
 * @param {Object} args
 */
Wi.FlashLoad = false;
Wi.FlashProxy = function(command, args){
    switch (command) {
        case 'W.Fxr':
            W.Fxr();
            break;
		case 'W.Fxrcp':
			W.Fxrcp(args);
			break;
        case 'W.Fxro':
            W.Fxro(args, W.BT);
            break;
        case 'Wi.Fue':
            if (args.indexOf(',') > -1) {
                var args = args.split(',');
                Wi.Fue(args[0], args[1]);
            }
            else {
                Wi.Fue(args);
            }            
            break;
        case 'Wi.Fu':
            Wi.Fu();
			Wi.FlashLoad = true;
            break;
		case 'Wi.Fp':
			Wi.Fp();
			break;
		case 'Wi.Fpa':
			Wi.Fpa();
			break;
		case 'Wi.Fpr':
			Wi.Fpr();
			break;
    }
};
	
Wi.liveFx = 'http://service.webeye.net.cn/4362/liveFx.swf';
Wi.liveFxId = 'wsdn_liveFx';
Wi.liveFxSrc = ['<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"', ' style="margin:0px;padding:0px;" width="0" height="0"', ' id="', Wi.liveFxId, '" ', 'codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab">', '<param name="movie" value="', Wi.liveFx, '" /><param name="quality" value="high" /><param name="allowScriptAccess" value="always" />', '<embed style="visibility:hidden;margin:0px;padding:0px;" src="', Wi.liveFx, '" quality="high" bgcolor="#ffffff" ', 'width="0" height="0" name="', Wi.liveFxId, '" ', ' id="', Wi.liveFxId, '" ', 'align="middle"', 'play="true"', 'loop="false"', 'quality="high"', 'allowScriptAccess="always"', 'type="application/x-shockwave-flash"', 'pluginspage="http://www.macromedia.com/go/getflashplayer">', '<\/embed>', '<\/object>'].join('');
/**
 * #287 - Js脚本应该可以安装在客户网站页面源代码的顶部
 * 2009-07-04 by gsyn77
 */
if (X.msie) {
	/**
	 * 针对万网等速成网站，只能装在网页源代码中间并且附加了许多第三方Js脚本的，可以使用.js?ins=middle方式指定其是安装在网页源代码<body>中的任意位置，可以直接使用document.write来完成FlashCookie的插入操作
	 * 2009-07-14 by gsyn77
	 */
	if (Wi.ins == 'middle') {
		document.write(['<scr', 'ipt for="', Wi.liveFxId, '" event="FSCommand(command,args)" language="Jscr', 'ipt">\nWi.FlashProxy(command,args);\n</scr', 'ipt>', '<scr', 'ipt for="wsdn_liveFu" event="FSCommand(command,args)" language="Jscr', 'ipt">\nWi.FlashProxy(command,args);\n</scr', 'ipt>\n', '<scr', 'ipt for="wsdn_liveFp" event="FSCommand(command,args)" language="Jscr', 'ipt">\nWi.FlashProxy(command,args);\n</scr', 'ipt>\n',Wi.liveFxSrc].join(''));
	}
	else {
		if (TASKLIST_AFTER_DOMCONTENT_LOAD) {
			TASKLIST_AFTER_DOMCONTENT_LOAD.push(function(){
				/**
			 * 2009-06-26 by gsyn77
			 * BUGFIX - Flash fscommand 在使用 innerHTML 时失去对事件的响应
			 * // 寫入IE 專用 FlashCookie交互仲介函數
			 * //document.write(['<scr', 'ipt language=\"VBScript\"\>\n', 'On Error Resume Next\n', 'Sub ' + Wi.liveFxId + '_FSCommand(ByVal command, ByVal args)\n', '	Call ' + Wi.liveFxId + '_DoFSCommand(command, args)\n', 'End Sub\n', '</scr', 'ipt\>'].join(''));
			 * // 寫入IE 專用 FlashFileUpload交互仲介函數
			 * // document.write(['<scr', 'ipt language=\"VBScript\"\>\n', 'On Error Resume Next\n', 'Sub wsdn_liveFu_FSCommand(ByVal command, ByVal args)\n', '	Call wsdn_liveFu_DoFSCommand(command, args)\n', 'End Sub\n', '</scr', 'ipt\>'].join(''));
			 */
				//document.write(['<scr', 'ipt for="', Wi.liveFxId, '" event="FSCommand(command,args)" language="Jscr', 'ipt">\nWi.FlashProxy(command,args);\n</scr', 'ipt>', '<scr', 'ipt for="wsdn_liveFu" event="FSCommand(command,args)" language="Jscr', 'ipt">\nWi.FlashProxy(command,args);\n</scr', 'ipt>'].join(''));
				
				/*
			 * FIXME
			 * 1. 防止由于document.write()造成客户站点的意外错误
			 * 2. 弹出窗口中如果使用insertBefore()则没有任何作用
			 */
				//document.write('<div id="wsdn_fxcon" style="width:0xp;height:0px;top:-1px;left:-1px;position:absolute;z-index:-1;"></div>');
				var hLiveFx = null, routeLoadLiveFx = function(){
					if (!X.isO(X.$('wsdn_fxcon'))) {
						var div = X.E('div');
						div.id = 'wsdn_fxcon';
						div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_WIDTH] = '0px';
						div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_HEIGHT] = '0px';
						div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_TOP] = '-1px';
						div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_LEFT] = '-1px';
						div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_POSITION] = 'absolute';
						div[TAG_ATTRIBUTE_STYLE][TAG_ATTRIBUTE_ZINDEX] = '-1';
						try {
							X.body().appendChild(div);
						} 
						catch (e) {
							X.LOG(e);
						}
					}
					
					if (div) {
						div.innerHTML = [Wi.liveFxSrc, '\n<scr', 'ipt for="', Wi.liveFxId, '" event="FSCommand(command,args)" language="Jscr', 'ipt">\nWi.FlashProxy(command,args);\n</scr', 'ipt>', '<scr', 'ipt for="wsdn_liveFu" event="FSCommand(command,args)" language="Jscr', 'ipt">\nWi.FlashProxy(command,args);\n</scr', 'ipt>','<scr', 'ipt for="wsdn_liveFp" event="FSCommand(command,args)" language="Jscr', 'ipt">\nWi.FlashProxy(command,args);\n</scr', 'ipt>'].join('');
					}
					else {
						hLiveFx = X.at(routeLoadLiveFx, 50);
					}
				}, //
 				hLiveFx = X.at(routeLoadLiveFx, 50);
			});
		}
	}
}
else {
    // 除了IE之外，其他浏览器（Firefox、Opera、Safari、Chromium）一般不会出现问题
    document.write(Wi.liveFxSrc);
}
 
        }
        else {
            W.BT();
        }
		/**
         * 用于在浏览器DomContentLoaded事件时执行事先设定的任务
         * 	since 2009-07-06 by gsyn77
         */
        W.after();
    }
//})();


})()