//必行JS文件库
//BxJsLib.js,包含通用JS库和方法,用于每个页面的加载
//版权所有必行科技(北京)有限公司,www.gumuren.com
//版本1.0
//创建时间2008.12.06
//修改时间2008.12.06
//修改人
//修改时间2008.12.06
//修改人 贾军伟
//修改记录 增加Bx.Cookie

(function ()
{
    if (window.Bx != null) { return; }
    Bx = new Object();
    Bx = new Object();
    //#region Bx.Environment 脚本环境
    Bx.Environment = new function ()
    {
        /// <summary>脚本环境设置</summary>

        this.WebSiteUrl = "/"; // "/Bx.WebSite/"; //网站应用根路径
        this.GetWebSiteUrl = function (url)
        {
            /// <summary>获取路径的绝对URL</summary>
            /// <param name="url">相对于网站应用程序根路径的Url</param>
            if (url !== null)
            {
                if (url.substring(0, 1) == "/") url = url.substring(1);
                return this.WebSiteUrl + url;
            }
            else
            {
                return this.WebSiteUrl;
            }
        }
        this.pluginList = [
        { name: "flash", checkVar: "window.SWFObject", url: "/js/plugins/flash.js" },
        { name: "ie6fix", checkVar: "window.Bx.Style.Ie6Fix", url: "/js/plugins/ie6fix.js" },
        { name: "messagebox", checkVar: "window.Bx.MessageBox", url: "/js/plugins/messagebox.js" },
        { name: "motion", checkVar: "window.Bx.Motion", url: "/js/plugins/motion.js" },
        { name: "validator", checkVar: "window.Bx.Validator", url: "/js/plugins/validator.js" },
        { name: "xmlapi", checkVar: "window.Bx.XML.API", url: "/js/plugins/xmlapi.js" },
        { name: "imagesplayer", checkVar: "window.ImagesPlayer", url: "/js/BxImagesPlayer.js" },
        { name: "article", checkVar: "window.Bx.Article", url: "/js/bxarticle.js" },
        { name: "fffix", checkVar: "window.bxFFix", url: "/js/plugins/fffix.js" },
        { name: "webmenu", checkVar: "window.BxMenu", url: "/js/bxmenu.js" },
        { name: "editor", checkVar: "window.bxFtb", url: "/htmleditor/editor.js" },
        { name: "guestbook", checkVar: "window.Bx.GuestBook", url: "/js/bxguestbook.js" },
        { name: "tab", checkVar: "window.Bx.Plugin.Others.Tab", url: "/js/plugins/tab.js" },
        { name: "user", checkVar: "window.bxUser", url: "/js/bxuser.js" },
        { name: "pageloader", checkVar: "window.Bx.Plugin.Others.PageLoader", url: "/js/plugins/pageloader.js" },
        { name: "comment", checkVar: "window.Bx.Comment", url: "/js/bxcomment.js" },
        { name: "itemhelp", checkVar: "window.Bx.Plugin.Others.ItemHelp", url: "/js/plugins/itemhelp.js" },
        { name: "sitemessage", checkVar: "window.Bx.SiteMessage", url: "/js/bxsitemessage.js" }
    ]; //插件列表
        this.addPlugin = function (name, checkVar, url)
        {
            /// <summary>向环境注册插件</summary>
            /// <param name="name">插件名称</param>
            /// <param name="checkVar">检测变量名称</param>
            /// <param name="url">插件路径</param>
            this.pluginList.push({ name: name, checkVar: checkVar, url: url });
        }
    }

    //#endregion 

    //#region  全局方法

    /*HTML编码*/
    HtmlEncode = function (text)
    {
        /// <summary>对字符串进行HTML编码</summary>
        /// <param name="text">要进行编码的文本</param>
        text = text.toString();
        text = text.replace(/&/g, "&amp;");
        text = text.replace(/"/g, "&quot;");
        text = text.replace(/</g, "&lt;");
        text = text.replace(/>/g, "&gt;");
        text = text.replace(/'/g, "&#39;");
        return text;

    }
    HtmlDecode = function (text)
    {
        /// <summary>对字符串进行HTML解码</summary>
        /// <param>要进行解码的文本</text>
        text = text.toString();
        text = text.replace(/&amp;/g, "&");
        text = text.replace(/&quot;/g, '"');
        text = text.replace(/&lt;/g, '<');
        text = text.replace(/&gt;/g, ">");
        text = text.replace(/&#39;/g, "'");
        return text;

    }
    addReady = function (fun)
    {
        /// <summary>给DOMLoaded事件绑定事件函数</summary>
        /// <param name="fun">回调函数</param>
        bxSys.addReady(fun);
    }
    addOnload = function (fun)
    {
        /// <summary>添加window.onload事件</summary>
        SysAddEvent(window, "onload", fun);
    }
    //#region 字符串原型扩展
    String.prototype.replaceAll = function (strSearch, strReplace)
    {
        /// <summary>替换字符串指定内容</summary>
        return this.replace(eval("/" + strSearch + "/g"), strReplace);
    }

    String.prototype.Trim = String.prototype.trim = function ()
    {
        /// <summary>去除字符串两端的空格</summary>
        var m = this.match(/^\s*(\S+(\s+\S+)*)\s*$/);
        return (m == null) ? "" : m[1];
    }
    String.prototype.padLeft = function (totalLength, paddingChar)
    {
        /// <summary>左对齐此实例中的字符，在左边用指定的字符填充以达到指定的总长度</summary>
        /// <param name="totalLength">总长度</param>
        /// <param name="paddingChar">填充字符</param>

        var l = totalLength - this.length;
        if (l > 0)
        {
            var s = "";
            for (var i = 0; i < l; i++)
            {
                s = s + paddingChar;
            }
            return s + this;
        }
        return this;
    }
    String.prototype.padRight = function (totalLength, paddingChar)
    {
        /// <summary>右对齐此实例中的字符，在右边用指定的字符填充以达到指定的总长度</summary>
        /// <param name="totalLength">总长度</param>
        /// <param name="paddingChar">填充字符</param>
        var l = totalLength - this.length;
        if (l > 0)
        {
            var s = "";
            for (var i = 0; i < l; i++)
            {
                s = s + paddingChar;
            }
            return this + s;
        }
        return this;
    }
    //#endregion 

    //#region 数组原型扩展

    Array.prototype.remove = function (arrayItem)
    {
        /// <summary>移除数组第一个匹配的对象</summary>
        /// <param name="arrayItem">要移除的对象</param>

        var i = -1;
        for (var j = 0; j < this.length; j++)
        {
            if (this[j] == arrayItem)
            {
                this.splice(j, 1);
                break;
            }
        }
    }
    Array.prototype.removeAt = function (index)
    {
        /// <summary>移除数组指定索引处的元素</summary>

        this.splice(index, 1);
    }
    Array.prototype.indexOf = function (arrayItem)
    {
        /// <summary>查询数组中第一个匹配对象,并返回该元素索引,如果不存在指定元素,则返回-1</summary>
        /// <param name="arrayItem">要查找的对象</param>

        for (var i = 0; i < this.length; i++)
        {
            if (this[i] == arrayItem)
            {
                return i;
            }
        }
        return -1;
    }
    Array.prototype.pushs = function (params)
    {
        /// <summary>给数组批量添加值</summary>
        /// <param name="params">要添加的多个参数值，用逗号隔开</param>

        for (var i = 0; i < arguments.length; i++)
        {
            this.push(arguments[i]);
        }
    }
    Array.prototype.insertAt = function (index, obj)
    {
        /// <summary>在数组指定位置插入对象</summary>
        /// <param name="index">索引位置</param>
        /// <param name="obj">要插入的对象</param>

        this.splice(index, 0, obj);
    }

    //#endregion 

    //#region 日期原型方法
    Date.prototype.getMonthDays = function ()
    {
        /// <summary>返回本月的天数</summary>
        var year = this.getFullYear();
        var month = this.getMonth() + 1;
        var solarMonth = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
        if (month == 2)
        {
            return (((year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0)) ? 29 : 28);
        }
        else
        {
            return (solarMonth[month - 1]);
        }
    }
    Date.prototype.addMonth = function (v)
    {
        /// <summary>本日期加上指定个月</summary>
        /// <param name="v">要增加的月数，可以为负数</param>
        this.setMonth(this.getMonth() + v);
        return this;
    }
    Date.prototype.addDays = function (v)
    {
        /// <summary>本日期加上指定个天数</summary>
        /// <param name="v">要增加的天数，可以为负数</param>
        var dt = this;
        var d = dt.getDate() + v;
        this.setDate(d);
        return this;
    }
    Date.prototype.format = function (format)
    {
        /// <summary>格式化输出日期</summary>

        var o = {
            "M+": this.getMonth() + 1, //月份        
            "d+": this.getDate(), //日        
            "h+": this.getHours() % 12 == 0 ? 12 : this.getHours() % 12, //小时        
            "H+": this.getHours(), //小时        
            "m+": this.getMinutes(), //分        
            "s+": this.getSeconds(), //秒        
            "q+": Math.floor((this.getMonth() + 3) / 3), //季度        
            "S": this.getMilliseconds() //毫秒        
        };
        var week = {
            "0": "\u65e5",
            "1": "\u4e00",
            "2": "\u4e8c",
            "3": "\u4e09",
            "4": "\u56db",
            "5": "\u4e94",
            "6": "\u516d"
        };
        if (/(y+)/.test(format))
        {
            format = format.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
        }
        if (/(E+)/.test(format))
        {
            format = format.replace(RegExp.$1, ((RegExp.$1.length > 1) ? (RegExp.$1.length > 2 ? "\u661f\u671f" : "\u5468") : "") + week[this.getDay() + ""]);
        }
        for (var k in o)
        {
            if (new RegExp("(" + k + ")").test(format))
            {
                format = format.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
            }
        }
        return format;
    }
    //#endregion
    _$ = function (obj)
    {
        if (obj == null) { return null; }
        obj.addCell = function (cell)
        {
            /// <summary>附加一个单元格</summary>
            if (this.tagName)
            {
                if (this.tagName == "TABLE")
                {
                    var i = this.rows.length;
                    if (cell)
                    {
                        if (i > 0) { this.rows[i - 1].appendChild(cell); } else { this.addRow().appendChild(cell); }
                        return cell;
                    }
                    else
                    {
                        return i > 0 ? this.rows[i - 1].insertCell(this.rows[i - 1].cells.length) : $(this.addRow()).addCell();
                    }
                }
                else if (this.tagName == "TR")
                {

                    if (cell)
                    {
                        this.appendChild(cell);
                        return cell;
                    }
                    else
                    {
                        return this.insertCell(this.cells.length);
                    }
                }
            }
        }
        obj.addRow = function (row)
        {
            /// <summary>附加一行</summary>
            if (this.tagName && this.tagName == "TABLE")
            {
                if (row)
                {
                    this.appendChild(row);
                    return _$(row);
                }
                else
                {
                    return _$(this.insertRow(this.rows.length));
                }
            }

        }
        obj.xy = function ()
        {
            /// <summary>返回对象基于页面的坐标位置，返回格式为{x,y}</summary>
            return bxStyle.xy(obj);
        }
        if (obj.text == null)
        {
            obj.text = function (str)
            {
                if (obj.innerText) { if (str) { obj.innerText = str; } else { return obj.innerText; } }
                else { if (str) { obj.textContent = str; } else { return obj.textContent; } }
            }
        }
        obj.html = function (str)
        {
            /// <summary>获取或设置对象的innerHTML值</summary>
            if (arguments.length == 0)
            {
                return obj.innerHTML;
            }
            else
            {
                obj.innerHTML = str;
            }
        }
        obj.set = function (options)
        {
            /// <summary>设置对象的属性值</summary>
            /// <param name="options">要设置的属性值，JSON格式</param>
            if (options)
            {
                for (var k in options)
                {
                    if (options.hasOwnProperty(k))
                    {
                        obj[k] = options[k];
                    }
                }
            }
        }
        return obj;
    }
    $ = function (expression)
    {
        /// <summary>取元素</summary>
        ///<param name="expression">元素ID或元素对象</param>
        var obj;
        if (typeof (expression) == "object")
        {
            obj = _$(expression);
        }
        else if (typeof (expression) == "string")
        {
            switch (expression)
            {
                case ("document.body"):
                    obj = _$(document.body);
                    break;
                default:
                    obj = _$(document.getElementById(expression));
                    break;
            }

        }
        return obj;
    }
    $P = function (childNode, parentTagName, parentDepth, isDepthOnly)
    {
        /// <summary>查找对像的父节点中具有指定标签名的对象</summary>
        /// <param name="childNode">子级点对象或对象表达式</param>
        /// <param name="parentTagName">要查询的父对象标签名称</param>
        /// <param name="parentDepth">要查询的父对象深度,即返回第几个满足标签名称要求的父对象.默认值为1</param>
        /// <param name="isDepthOnly">父对象深度是否精确要求.如果值为False,则在没有满足parentDepth情况下则返回不满足parentDepth的最外层父对象.如果值为True,则在没有满足parentDepth情况下返回null.默认为False</param>
        var obj = $(childNode);
        if (typeof (parentTagName) == "string")
        {
            parentTagName = parentTagName.toLowerCase();
            if (parentDepth == null)
            {
                parentDepth = 1;
            }
            if (isDepthOnly == null)
            {
                isDepthOnly = false;
            }
            var po = obj;
            var t = null;
            var i = 0;
            while (po)
            {
                po = obj.parentNode;
                if (po == obj || po == null)
                {
                    if (i > 0 && !isDepthOnly)
                    {
                        return t;
                    }
                    else
                    {
                        return null;
                    }
                }
                if (po.tagName != null && (po.tagName.toLowerCase() == parentTagName))
                {
                    t = po;
                    i++;
                    if (i == parentDepth)
                    {
                        return t;
                    }
                }
                obj = po;
            }
        }
        else
        {
            return null;
        }

    }
    $T = function (expression, parentObj)
    {
        /// <summary>获取指定标签名的标签数组</summary>
        /// <param name="expression">标签名表达式</param>
        /// <param name="parentObj">父对象，默认为document</param>
        var tarray = Array();
        var pp = parentObj ? parentObj : document;
        tarray = pp.getElementsByTagName(expression);
        var rs = [];
        for (var i = 0; i < tarray.length; i++)
        {
            rs.push(_$(tarray[i]));
        }
        return rs;
    }
    $C = function (expression, parentObj, tagName)
    {
        /// <summary>获取包含指CSS类的元素数组</summary>
        /// <param name="expression">CSS类名</param>
        /// <param name="parentObj">在指定对象下面搜索</param>

        var objs;
        if (arguments.length == 3) { objs = parentObj.getElementsByTagName(tagName); }
        else { objs = document.all ? document.all : document.getElementsByTagName("*"); }
        var rs = [];
        for (var i = 0; i < objs.length; i++)
        {
            var cns = objs[i].className.split(/ +/);
            for (var j = 0; j < cns.length; j++)
            {
                if (cns[j] == expression)
                {
                    rs[rs.length] = _$(objs[i]);
                }
            }
        }
        return rs;
    }
    $E = function (tagName, initProperty, doc)
    {
        /// <summary>创建标签对象</summary>
        /// <param name="tagName">标签名称</param>
        /// <param name="doc">document对象，默认为当前 document</param>
        var doc = doc ? doc : document;
        var o = doc.createElement(tagName);
        if (initProperty)
        {
            for (var key in initProperty)
            {
                if (initProperty.hasOwnProperty(key))
                {
                    o[key] = initProperty[key];
                }
            }
        }
        return $(o);
    }
    Object.prototype.p = function (name, defaultValue)
    {
        /// <summary>查询对象的指定属性，兼容标签属性</summary>
        /// <param name="name">要查询的属性名称</param>
        /// <param name="defaultValue">当不具有该对象时返回值</param>        
        return (this != null && (name in this)) ? this[name] : ((this.attributes && (this.attributes[name] != null)) ? this.attributes[name].value : (arguments.length == 2 ? defaultValue : null));
    }
    //#endregion

    //#region 查询字符串组合类
    bxQueryString = function (rawString, isHtmlMode)
    {
        /// <summary>查询字符串组合类</summary>
        /// <param name="rawString">原始字符串</param>
        /// <param name="isHtmlMode">True：使用Html编码，False：使用Url编码</param>
        var vs = new Array();
        var htmlMode = arguments.length == 2 ? isHtmlMode : true;

        function loadString()
        {
            if (rawString.length > 0)
            {
                var s;
                if (htmlMode)
                {
                    s = rawString.split("&&");
                    for (var i = 0; i < s.length; i++)
                    {
                        var a = s[i].split(">");
                        vs.pushs(a[0], HtmlDecode(a[1]));
                    }
                }
                else
                {
                    s = rawString.split("&");
                    for (var i = 0; i < s.length; i++)
                    {
                        var a = s[i].split("=");
                        vs.pushs(a[0], decodeURIComponent(a[1]));
                    }
                }
            }
        }
        loadString();
        this.getValue = function (name, defaultValue)
        {
            for (var i = 0; i < vs.length; i = i + 2)
            {
                if (vs[i] == name) { return vs[i + 1]; }
            }
            if (defaultValue != null)
            {
                return defaultValue;
            }
            else
            {
                return null;
            }
        }
        this.setValue = function (name, value)
        {
            /// <summary>设置键值，该方法为自动把value值转换成字符串格式</summary>
            value = value.toString()
            for (var i = 0; i < vs.length; i = i + 2)
            {
                if (vs[i] == name) { vs[i + 1] = value; return; }
            }
            vs.pushs(name, value);
        }
        this.setValues = function (name, value)
        {
            for (var i = 0; i < arguments.length; i = i + 2)
            {
                this.setValue(arguments[i], arguments[i + 1]);
            }
        }
        this.getQueryString = function ()
        {
            if (htmlMode)
            {
                var s = "";
                for (var i = 0; i < vs.length; i = i + 2)
                {
                    s += ("&&" + vs[i] + ">" + ((vs[i + 1] != null && vs[i + 1].length > 0) ? HtmlEncode(vs[i + 1]) : ""));
                }
                if (s.length > 0)
                {
                    return s.substring(2, s.length);
                }
                else
                {
                    return "";
                }
            }
            else
            {
                var s = "";
                for (var i = 0; i < vs.length; i = i + 2)
                {
                    s += ("&" + vs[i] + "=" + ((vs[i + 1] != null && vs[i + 1].length > 0) ? encodeURIComponent(vs[i + 1]) : ""));
                }
                if (s.length > 0)
                {
                    return s.substring(1, s.length);
                }
                else
                {
                    return "";
                }
            }
        }
    }
    //#endregion

    //#region   Bx.NavigatorNavigator浏览器类开始
    Bx.Navigator = new Object();
    Bx.Navigator.Info = bxNavigator = function ()
    {
        /// <summary>浏览器信息对象</summary>
        var rObj = { IsIE: false, IsIE6: false, IsIE7: false, IsIE8: false, IsIE9: false, IsFireFox: false, IsOther: false };
        var str = navigator.userAgent.toLowerCase();

        if (/msie (8.0)/.test(str)) { rObj.IsIE = rObj.IsIE8 = true; } else if (/msie (7.0)/.test(str)) { rObj.IsIE = rObj.IsIE7 = true; } else if (/msie (9.0)/.test(str)) { rObj.IsIE = rObj.IsIE9 = true; } else if (/msie (5\.5|6\.)/.test(str)) { rObj.IsIE = rObj.IsIE6 = true; } else if (/firefox/.test(str)) { rObj.IsFireFox = true; } else { rObj.IsOther = true; }
        return rObj;
    } ();

    //#endregion

    //#region Bx.Pub公共类
    Bx.Pub = bxPub = function ()
    {
        /// <summary>公共方法类</summary>
        return {
            parseBool: function (v)
            {
                /// <summary>转换对象为布尔值</summary>
                /// <param name="v">要转换的对象</param>
                if (v == true || v == false) { return v; }
                else if (typeof (v) == "string")
                { return v.toLowerCase() == "true"; }
                else if (typeof (v) == "number") { return v != 0; }
                else { return false; }
            },
            parseFloat: function (v, defaultValue)
            {
                /// <summary>转换对像为float值</summary>
                /// <param name="v">要转换的值</param>
                /// <param name="defaultValue">默认值</param>

                var f = parseFloat(v);
                if (isNaN(f))
                {
                    if (defaultValue != null) { return defaultValue; }
                }
                return f;
            },
            urlRandom: function (url)
            {
                /// <summary>给URL附加一个随机参数，避开浏览器缓存</summary>
                /// <param name="url">源URL</param>
                return bxUrlReplaceValue("irand", parseInt(Math.random() * 100), url);
            },
            getUniqueID: function ()
            {
                /// <summary>生成页面内一个唯一的ID标识</summary>
                if (window._uid == 0 || window._uid == NaN || window._uid == null)
                {
                    window._uid = 0;
                }
                window._uid++;
                return "bxid" + window._uid;
            },
            valueToHtml: function (v)
            {
                /// <summary>把文本框控件的值转换为HTML格式</summary>
                return v.replace(/<(.+?)>/gi, "&lt;$1&gt;").replace(/ /gi, "&nbsp;").replace(/\n/gi, "<br>");
                ;
            },
            htmlToValue: function (v)
            {
                /// <summary>把HTML格式转换为文本框值格式</summary>
                return v;
            },
            checkTagName: function (tagObj, tagName)
            {
                /// <summary>检测对象是否具有指定标签名</summary>
                /// <param name="tagObj">要检测的标签对象</param>
                /// <param name="tagName">目标标签名称</param>
                var tagObj = $(tagObj);
                return tagObj.tagName.toLowerCase() == tagName.toLowerCase();
            },
            getMousePosition: function (event, isOffsetDocument)
            {
                /// <summary>返回当前鼠标坐标位置，返回格式为{x,y}</summary>
                /// <param name="evt">事件对象</param>
                /// <param name="isOffsetDocument">true(默认):返回相对于整个文档的值，false:返回相关于当前可见网页部分的值</param>

                var evt = event || window.event;
                var bd = bxGetBodyDocumentElement(window.top);
                var isOffsetDocument = isOffsetDocument == null ? true : isOffsetDocument;
                if (evt.pageX || evt.pageY)
                {
                    if (isOffsetDocument)
                    {
                        return { x: evt.pageX, y: evt.pageY };
                    } else
                    {
                        return { x: evt.pageX - bd.scrollLeft, y: evt.pageY - bd.scrollTop };
                    }
                }
                if (isOffsetDocument)
                {
                    return {
                        x: evt.clientX + bd.scrollLeft,
                        y: evt.clientY + bd.scrollTop
                    };
                }
                else
                {
                    return {
                        x: evt.clientX + bd.scrollLeft - bd.clientLeft,
                        y: evt.clientY + bd.scrollTop - bd.clientTop
                    };
                }
            },
            clearFileInput: function (file)
            {
                /// <summary>清空file控件</summary>
                /// <param name="file">要操作的file对象</param>

                var form = document.createElement('form');
                document.body.appendChild(form);
                //记住file在旧表单中的的位置
                var pos = file.nextSibling;
                form.appendChild(file);
                form.reset();
                pos.parentNode.insertBefore(file, pos);
                document.body.removeChild(form);
            },
            extend: function (destination, source)
            {
                /// <summary>复制源对象属性到目标对象</summary>
                /// <param name="destination">目标对象</param>
                /// <param name="source">源对象</param>
                if (source == null) { return destination; }
                for (var property in source)
                {
                    destination[property] = source[property];
                };
                return destination;
            },
            isFunction: function (obj)
            {
                /// <summary>判断对象是否是函数</summary>
                return (obj && obj.constructor == window.Function);
            },
            htmlTagToLowerCase: function (html)
            {
                /// <summary>转换html标记中所有大写成小写</summary>
                return html.replace(/(<\/?\w+)(\s*?.*?>)/gi, function ($0, $1, $2)
                {
                    return $1.toLowerCase() + $2;
                });


            },
            open: function (url)
            {
                /// <summary>弹窗打开URL</summary>
                window.open(url);
            },
            timeToSpan: function (dt)
            {
                /// <summary>转换日期为时间片段表达式</summary>
                var dt = dt.constructor == Date.constructor ? dt : Date.parse(dt);
                var ts = bxParseInt((new Date() - dt) / 1000, 1);
                var h = bxParseInt(ts / 3600, 0);
                if (h >= 720)
                {
                    s = bxParseInt(h / 720, 1) + " 月前 ";
                }
                else if (h >= 168)
                {
                    s = bxParseInt(h / 168, 1) + " 周前";
                }
                else if (h >= 24)
                {
                    s = bxParseInt(h / 24, 1) + " 天前";
                }
                else if (h >= 1)
                {
                    s = h + " 小时前";
                }
                else
                {
                    var m = ts / 60;
                    if (m >= 1)
                    {
                        s = bxParseInt(m, 1) + "分钟前";
                    }
                    else
                    {
                        s = ts + " 秒前";
                    }
                }
                return s;
            },
            htmlEncode: function (text)
            {
                /// <summary>对字符串进行HTML编码</summary>
                /// <param name="text">要进行编码的文本</param>
                text = text.toString();
                text = text.replace(/&/g, "&amp;");
                text = text.replace(/"/g, "&quot;");
                text = text.replace(/</g, "&lt;");
                text = text.replace(/>/g, "&gt;");
                text = text.replace(/'/g, "&#39;");
                return text;
            },
            htmlDecode: function (text)
            {
                /// <summary>对字符串进行HTML解码</summary>
                /// <param>要进行解码的文本</text>
                text = text.toString();
                text = text.replace(/&amp;/g, "&");
                text = text.replace(/&quot;/g, '"');
                text = text.replace(/&lt;/g, '<');
                text = text.replace(/&gt;/g, ">");
                text = text.replace(/&#39;/g, "'");
                return text;
            }


        }
    } ();
    Bx.Pub.GetFeature = bxGetFeatures = function (featureString, featureName, defaultValue, isDouhao)
    {
        /// <summary>从特征字符串中查找指定的特征值</summary>
        /// <param name="featureString">特征字符串,开如f1:v1;f2:v2;</param>
        /// <param name="featureName">特征值名字</param>
        /// <param name="defaultValue">不包含指定值时返回的默认值</param>
        /// <param name="isDouhao">是否解析为逗号分隔符，默认为False，即使用分号分隔符</param>

        if (!featureName || !featureString) { return defaultValue; }
        if (typeof (featureString) == "object") { return featureString.p(featureName, defaultValue); }
        var fs = isDouhao ? featureString.split(",") : featureString.split(";");
        for (var i = 0; i < fs.length; i++)
        {
            var fvs = fs[i].split(":");
            if (fvs[0].Trim() == featureName)
            {
                return fvs[1].Trim();
            }
        }
        return defaultValue;

    }
    Bx.Pub.getProperty = bxGetProperty = function (obj, name, defaultValue)
    {
        /// <summary>查询对象的指定属性</summary>
        /// <param name="obj">要操作的对象</param>    
        /// <param name="name">要查询的属性名称</param>
        /// <param name="defaultValue">当不具有该对象时返回值</param>
        return (obj != null && (name in obj)) ? obj[name] : (arguments.length == 3 ? defaultValue : null);
    }
    Bx.Pub.parseInt = bxParseInt = function (v, defaultValue)
    {
        /// <summary>转换对象为整数</summary>
        /// <param name="v">要转换的输入值</param>
        /// <param name="defaultValue">转换失败时返回的默认值</param>

        var o = parseInt(v);
        if (isNaN(o)) { o = defaultValue; }
        return o;
    }
    Bx.Pub.$A = $A = function (parentObj, tagName, attributeName, attributeValue)
    {
        /// <summary>根据标签名和属性查找子节点</summary>
        /// <param name="parentObj">要查找的父对象</param>
        /// <param name="tagName">匹配的子节点的标签</param>
        /// <param name="attributeName">匹配的属性名</param>
        /// <param name="attributeValue">匹配的属性值,默认忽略</param>

        var pObj = $(parentObj); if (!pObj) { return []; }
        var objs = pObj.getElementsByTagName(tagName);
        var rojbs = new Array();
        if (attributeValue)
        {
            for (var i = 0; i < objs.length; i++)
            {
                if (objs[i].attributes[attributeName] && (objs[i].attributes[attributeName].value == attributeValue))
                {
                    rojbs[rojbs.length] = objs[i];
                }
            }
        }
        else
        {
            for (var i = 0; i < objs.length; i++)
            {

                if (objs[i].attributes[attributeName])
                {

                    rojbs[rojbs.length] = objs[i];
                }
            }
        }
        return rojbs;
    }
    Bx.Pub.$N = $N = function (name)
    {
        /// <summary>查询name属性为指定值的元素集合</summary>
        /// <param name="name">要查询的name值</param>
        var os = document.getElementsByName(name);
        var os2 = new Array();
        bxBatch(os, function (obj, index)
        {
            if (obj.getAttribute("name") == name || (obj.name == name))
            {
                os2.push(obj);
            }
        });
        return os2;
    }
    Bx.Pub.GetUrl = function ()
    {
        /// <summary>获取当前的URL</summary>
        return window.location;
    }
    Bx.Pub.GetUrlWithoutParam = function (strUrl)
    {
        /// <summary>获取URL地址不带参数部分</summary>
        /// <param name="strUrl">原始URL字符串</param>
        /// <return>返回URL地址不带参数部分</return>
        var urls = strUrl.split("?");
        return urls[0];
    }


    Bx.Pub.GetUrlParam = bxGetUrlParam = function (name, rawUrl, isReturnNull)
    {
        /// <summary>获取UrlGet参数，如果参数不存在则返回""</summary>
        /// <param name="name">要获取的参数名称</param>
        /// <param name="rawUrl">原始URL，默认为当前客户端URL</param>
        /// <param name="isReturnNull">不存在此参数时的返回值,True:返回null值，False(默认):返回""</param>

        var str = rawUrl ? rawUrl : window.location.href;
        if (str.indexOf("?") >= 0)
        {
            str = str.substring(str.indexOf("?"));
        }
        var index = Math.max(str.indexOf("&" + name + "="), str.indexOf("?" + name + "="));
        if (index >= 0)
        {
            var pos_start = index + name.length + 2;
            var p1 = str.indexOf("&", pos_start), p2 = str.indexOf("#", pos_start);
            var pos_end = p1 < 0 ? p2 : (p2 < 0 ? p1 : Math.min(p1, p2));
            if (pos_end == -1)
            {
                return str.substring(pos_start);
            }
            else
            {
                return str.substring(pos_start, pos_end)
            }
        }
        else
        {
            if (isReturnNull == true) { return null } else { return ""; }
        }
    }
    Bx.Pub.UrlReplaceParamValue = bxUrlReplaceValue = function (paramName, newParamValue, rawUrl)
    {
        /// <summary>替换URL中的参数值，如果不存在则添加</summary>
        /// <param name="paramName">参数名称</param>
        /// <param name="newParamValue">新的参数值</param>
        /// <param name="rawUrl">要操作的URL，默认为当前客户端URL</param>
        var oUrl = rawUrl ? rawUrl : window.location.href.toString();
        var nUrl = "";
        var urls = oUrl.split("#");
        oUrl = urls[0];
        if (bxGetUrlParam(paramName, oUrl, true) == null)
        {

            if (oUrl.indexOf("?") > 0)
            {
                nUrl = oUrl + ("&" + paramName + "=" + newParamValue);
            }
            else
            {
                nUrl = oUrl + ("?" + paramName + "=" + newParamValue);
            }
        }
        else
        {
            var re = eval('/([?&])(' + paramName + '=[^&#]*)/gi');
            //alert(oUrl.match(re));
            nUrl = oUrl.replace(re, "$1" + paramName + '=' + newParamValue);
        }
        if (urls.length > 1)
        {
            nUrl += ("#" + urls[1]);
        }
        return nUrl;
    }
    Bx.Pub.SetClipboardText = SetClipboardText = function (text)
    {
        /// <summary>设置客户端剪贴板的文本内容</summary>
        /// <param name="text">要设置的文本值</param>
        window.clipboardData.setData("text", text.toString())
    }
    Bx.Pub.SelectSetValue = SelectSetValue = function (selectObj, value, text)
    {/// <summary>设置下拉控件的先择值</summary>
        /// <param name="value">要匹配的值，如果设为null，则匹配text参数</param>
        /// <param name="text">当value参数为 null时，匹配文本</param>

        var obj = $(selectObj);
        if (obj)
        {
            for (var i = 0; i < obj.options.length; i++)
            {
                var op = obj.options[i];
                if (value)
                {
                    if (op.value == value)
                    {
                        obj.selectedIndex = i; break;
                    }
                }
                else if (text && op.text == text)
                {
                    obj.selectedIndex = i; break;
                }
            }
        }
    }
    Bx.Pub.SelectGetOptions = SelectGetOptions = function (selectObj, value, text)
    {
        /// <summary>返回下拉控件的选择项option对象集合引用</summary>
        /// <param name="value">要匹配的值，如果设为null，则忽略参数</param>
        /// <param name="text">当value参数为 null时，忽略此参数</param>
        var obj = $(selectObj);
        if (obj)
        {
            if (value == null && text == null)
            {
                return obj.options;
            }
            var ops = new Array();
            for (var i = 0; i < obj.options.length; i++)
            {
                var op = obj.options[i];
                if (value && value != op.value)
                {
                    continue;
                }
                if (text && op.text != text)
                {
                    continue;
                }
                ops[ops.length] = op;
            }
            return ops;
        }
        else
        {
            return null;
        }
    }
    Bx.Pub.InputRadioSetValue = InputRadioSetValue = function (controlName, selectedValue)
    {
        var objs = document.getElementsByName(controlName);
        for (var i = 0; i < objs.length; i++)
        {
            if (objs[i].value == selectedValue)
            {
                objs[i].checked = true;
                break;
            }
        }
    }
    Bx.Pub.InputRadioGetValue = InputRadioGetValue = function (controlName, defaultValue)
    {
        var objs = document.getElementsByName(controlName);
        for (var i = 0; i < objs.length; i++)
        {
            if (objs[i].checked)
            {
                return objs[i].value;
            }
        }
        return defaultValue;

    }
    Bx.Pub.SubmitKeyClick = SubmitKeyClick = function (evt, button, func)
    {
        /// <summary>设置处理对象提交事件</summary>
        /// <param name="button">要绑定的提交按钮</param>
        evt = evt ? evt : window.event;
        me = evt.srcElement || evt.target;

        var keyCode = evt.which || evt.keyCode;
        if (keyCode == 13)
        {
            if (document.all)
            {
                evt.keyCode = 9;
                evt.returnValue = false;
            }
            else
            {
                evt.preventDefault();
            }
            if (button && button.length > 0)
            {
                $(button).click();
            }
            else if (func)
            {
                func();
            }
        }
    }
    Bx.Pub.ParseAbsoluteUrl = function (targetUrl, thisUrl)
    {
        /// <summary>转换URL地址为绝对URL地址</summary>
        /// <param name="targetUrl">要转换的目标URL</param>
        /// <param name="thisUrl">参考URL，默认为当前页面URL</param> 
        thisUrl = thisUrl ? thisUrl : window.location.pathname;
        thisUrl = thisUrl.substring(0, thisUrl.lastIndexOf("/") + 1);
        if ((targetUrl.substring(0, 7).toLowerCase() == "http://") || (targetUrl.substring(0, 8).toLowerCase() == "https://") || (targetUrl.substring(0, 1).toLowerCase() == "/")) { return targetUrl; }
        else { targetUrl = thisUrl + targetUrl; }
        return targetUrl;
    }
    Bx.Pub.Batch = bxBatch = function (objsArray, fun)
    {
        /// <summary>批处理对象</summary>
        /// <param name="objsArray">要批处理的对象数组</param>
        /// <param name="fun">要执行的回调方法，该方法第一个参数为处理对象，第二个参数为该对象在数组中的索引</param>
        //if ((objsArray == null) || (objsArray.constructor != window.Array) ||( typeof (fun) != "function")) { return 0; }
        for (var i = 0; i < objsArray.length; i++)
        {
            fun(objsArray[i], i);
        }
        return objsArray.length;
    }
    Bx.Pub.Alert = bxAlert = function (messages)
    {
        /// <summary>弹出消息框</summary>
        /// <param name="messages">要弹出的信息，可以多个值，用逗号分开</param>
        if (arguments.length == 1) { alert(messages); return; }
        var s = "";
        for (var i = 0; i < arguments.length; i++)
        {
            s = s + (" " + arguments[i]);
        }
        alert(s);
    }
    Bx.Pub.GetRandom = bxGetRandom = function (vMax, vMin)
    {
        /// <summary>范围指定范围的整数随机值</summary>
        /// <param name="vMax">最大值</param>
        /// <param name="vMin">最小值，默认值为0</param>
        var vMin = vMin != null ? vMin : 0;
        return parseInt(Math.random() * (vMax - vMin + 1) + vMin);
    }
    //#endregion

    //#region Bx.Sys系统类
    Bx.Sys = bxSys = function ()
    {

        var DOMReady = {
            isLoaded: false,
            fns: [],
            exec: function ()
            {
                DOMReady.isLoaded = true;
                for (var i = 0; i < DOMReady.fns.length; i++)
                {
                    DOMReady.fns[i]();
                }
                DOMReady.fns.length = 0;
            },
            add: function (fun)
            {
                DOMReady.fns.push(fun);
                if (DOMReady.isLoaded) { DOMReady.exec(); }
            },
            ready: function ()
            {
                var u = navigator.userAgent;
                if (/webkit/i.test(u))
                {
                    (function ()
                    {
                        var dr = document.readyState;
                        if (dr == "loaded" || dr == "complete")
                        {
                            DOMReady.exec();
                        } else
                        {
                            setTimeout(arguments.callee, 10);
                        }
                    })();
                } else if (document.addEventListener && !bxNavigator.IsIE)
                { //添加DOMContentLoaded事件的支持
                    document.addEventListener("DOMContentLoaded", function () { DOMReady.exec(); }, false);
                } else
                {
                    (function ()
                    {
                        var t = document.createElement('doc:rdy');
                        try
                        {
                            t.doScroll('left');
                            DOMReady.exec();
                            t = null;
                        } catch (e)
                        {
                            setTimeout(arguments.callee, 1);
                        }
                    })();
                }


            }
        };
        DOMReady.ready();
        return {
            stopPropagation: function (evt)
            {
                /// <summary>取消事件冒泡</summary>
                if (window.event) { window.event.cancelBubble = true; }
                else if (evt) { evt.stopPropagation(); }
            },
            cancelBubble: function (evt)
            {
                /// <summary>取消事件冒泡</summary>
                if (window.event) { window.event.cancelBubble = true; }
                else if (evt) { evt.stopPropagation(); }
            },
            preventDefault: function (evt)
            {
                /// <summary>通知浏览器不要执行与事件关联的默认动作</summary>
                if (window.event) { window.event.returnValue = false; }
                else { evt.preventDefault(); }
            },
            addEventHandler: function (target, eventName, callBack)
            {
                /// <summary>向对象添加一个事件代理</summary>
                /// <param name="target">目标对象</param>
                /// <param name="eventName">事件名称</param>
                /// <param name="callBack">事件处理函数，形如function(evt,eventSrc){}，传入参数为事件处理对象和事件源对象</param>

                var f = function (evt)
                {
                    var src = bxGetEventSrc(evt);
                    callBack(evt, src);
                }
                SysAddEvent(target, eventName, f);
            },
            extendDOMElement: function (name, fn)
            {
                //给DOMElement添加名称为name的方法fn
                var _f = _$;
                _$ = function (obj)
                {
                    var _elem = _f(obj);
                    if (_elem) { _elem[name] = fn; }
                    return _elem;
                }
                if (window.HTMLElement)//除了ie而外的浏览器都能够访问到HTMLElement这个类
                    eval("HTMLElement.prototype." + name + " = fn");
                else
                {
                    //    IE中不能访问HTMLElement这个类
                    //    为了达到同样的目的，必须重写下面几个函数
                    //    document.createElement
                    //    document.getElementById
                    //    document.getElementsByTagName
                    //    这几个函数都是获得HTML元素的方法
                    //    修改这些方法，使得通过这些方法获得的每个元素拥有名称为name的方法fn

                    var _createElement = document.createElement;
                    document.createElement = function (tag)
                    {
                        var _elem = _createElement(tag);
                        if (_elem) { _elem[name] = fn; } //eval("_elem." + name + " = fn");也可以达到同样的目的
                        return _elem;
                    }

                    var _getElementById = document.getElementById;
                    document._getElementById = document.getElementById = function (id)
                    {
                        var _elem = _getElementById(id);
                        if (_elem) { _elem[name] = fn; }
                        return _elem;
                    }

                    var _getElementsByTagName = document.getElementsByTagName;
                    document.getElementsByTagName = function (tag)
                    {
                        var _arr = _getElementsByTagName(tag);
                        for (var _elem = 0; _elem < _arr.length; _elem++)
                            eval("_arr[_elem]." + name + " = fn");
                        return _arr;
                    }
                }
            },
            runJsFile: function (jsURL, funReceive, isAsync)
            {
                /// <summary>动态加载JS</summary>
                /// <param name="jsURL">js文件URL</param>
                /// <param name="funReceive">回调函数</param>
                var isAsync = (isAsync == null ? true : isAsync);
                bxAjax.getURL(jsURL, function (response)
                {
                    eval(response.text);
                    if (response)
                    {
                        funReceive(response);
                    }
                }, isAsync);
            },
            addReady: function (fun)
            {
                /// <summary>给DOMLoaded事件绑定事件函数</summary>
                /// <param name="fun">回调函数</param>
                DOMReady.add(fun);
            }
        }


    } ();

    Bx.Sys.AddEvent = SysAddEvent = function (objExpression, eventName, callBack)
    {
        /// <summary>给对象添加事件</summary>
        /// <param name="objExpression">对象或对象ID</param>
        /// <param name="eventName">事件名称</param>
        /// <param name="callBack">回调函数</param>

        if (typeof (objExpression) == "string")
        {
            if ($(objExpression) == null)
            {
                SysAddEvent(window, "onload", function () { SysAddEvent(objExpression, eventName, callBack); });
                return;
            }
        }
        var obj = $(objExpression);
        if (obj.addEventListener)
        {
            if (eventName.substring(0, 2) == "on") eventName = eventName.substring(2, eventName.length);
            obj.addEventListener(eventName, callBack, false);
        } else if (obj.attachEvent)
        {//IE
            if (eventName.substring(0, 2) != "on") eventName = "on" + eventName;
            obj.attachEvent(eventName, callBack);
        } else
        {
            if (eventName.substring(0, 2) != "on") eventName = "on" + eventName;
            obj[eventName] = callBack;
        }
    }
    Bx.Sys.RemoveEvent = SysRemoveEvent = function (objExpression, eventName, callBack)
    {
        /// <summary>删除通过Bx.Sys.AddEvent()方法添加的事件</summary>
        /// <param name="objExpression">对象或对象ID</param>
        /// <param name="eventName">事件名称</param>
        /// <param name="callBack">要删除的回调函数</param>
        if (typeof (objExpression) == "string")
        {
            if ($(objExpression) == null)
            {
                SysAddEvent(window, "onload", function () { Bx.Sys.RemoveEvent(objExpression, eventName, callBack); });
                return;
            }
        }
        var obj = $(objExpression);
        if (obj.removeEventListener)
        {
            if (eventName.substring(0, 2) == "on") eventName = eventName.substring(2, eventName.length);
            obj.removeEventListener(eventName, callBack, false);
        } else if (obj.detachEvent)
        {//IE
            if (eventName.substring(0, 2) != "on") eventName = "on" + eventName;
            obj.detachEvent(eventName, callBack);
        } else
        {
            if (eventName.substring(0, 2) != "on") eventName = "on" + eventName;
            obj[eventName] = "";
        }
    }


    Bx.Sys.LoadJsCssFile = SysLoadJsCssFile = function (filename, filetype)
    {
        /// <summary>向页面的Head标签添加Js脚本文件或Css样式表文件</summary>
        /// <param name="filename">文件Url</param>
        /// <param name="filetype">文件类型,值取"js"或"css"</param>

        if (filetype == "js")
        {
            var fileref = document.createElement('script');
            fileref.setAttribute("type", "text/javascript");
            fileref.setAttribute("src", filename)
        } else if (filetype == "css")
        {
            var fileref = document.createElement("link");
            fileref.setAttribute("rel", "stylesheet");
            fileref.setAttribute("type", "text/css");
            fileref.setAttribute("href", filename)
        }
        if (typeof fileref != "undefined") document.getElementsByTagName("head")[0].appendChild(fileref)
    }

    Bx.Sys.GetEventSrc = bxGetEventSrc = function (evt)
    {
        /// <summary>获取鼠标事件对象</summary>
        var evt = evt ? evt : event;
        if (evt.srcElement)
        {
            return evt.srcElement;
        }
        else
        {
            return evt.target;
        }
    }
    Bx.Sys.EventHandler = bxEventHandler = function ()
    {
        /// <summary>事件代理操作类</summary>
        var events = new Array();
        return {
            addEventListener: function (eventName, callBack)
            {
                /// <summary>给指定事件绑定处理句柄</summary>
                events.push({ eventName: eventName, callBack: callBack });
            },
            removeEventListener: function (eventName, callBack)
            {
                /// <summary>删除指定事件的指定处理句柄</summary>
                var evs = this.getEvents(eventName);
                for (var i = 0; i < evs.length; i++)
                {
                    var ev = evs[i];
                    if (callBack == null || ev.callBack == callBack)
                    {
                        events.Remove(ev);
                    }
                }
            },
            getEvents: function (eventName)
            {
                /// <summary>查询指定事件集</summary>
                /// <param name="eventName">事件名称</param>
                var evs = new Array();
                for (var i = 0; i < events.length; i++)
                {
                    var ev = events[i];
                    if (ev.eventName == eventName)
                    {
                        evs.push(ev);
                    }
                }
                return evs;
            },
            execEvent: function (eventName, args)
            {
                /// <summary>执行指定事件</summary>

                var evs = this.getEvents(eventName);
                var as = [];
                for (var i = 1; i < arguments.length; i++) { as.push(arguments[i]); }
                for (var i = 0; i < evs.length; i++) { evs[i].callBack.apply(this, as); }
            }
        }
    }
    //#endregion 

    //#region Bx.Math数学类
    Bx.Math = bxMath = function ()
    {
        return {
            getAvarage: function (dataArray)
            {
                /// <summary>获取数值数组元素的平均值</summary>
                /// <param name="dataArray">要计算的数组,必须是数值型一维数组</param>
                var tv = 0;
                for (var i = 0; i < dataArray.length; i++)
                {
                    tv += dataArray[i];
                }
                return tv / dataArray.length;
            },
            convertJiaoToRad: function (jiaoValue)
            {
                /// <summary>把角度转换成弧度</summary>
                /// <param name="jiaoValue">要转换的角度值</param>
                return jiaoValue * Math.PI / 180;
            },
            convertRadToJiao: function (radValue)
            {
                /// <summary>把角度转换成弧度</summary>
                /// <param name="radValue">要转换的弧度值</param>
                return radValue * 180 / Math.PI;
            },
            getArraySum: function (numberArray)
            {
                /// <summary>获取数字数组的总和</summary>
                /// <param name="numberArray">要计算的数值数组</param>
                var s = 0;
                for (var i = 0; i < numberArray.length; i++)
                {
                    s += numberArray[i];
                }
                return s;
            },
            toHexColor: function (v)
            {
                /// <summary>转换颜色值为16进制格式</summary>

                if (v.indexOf("#") >= 0) return v; //如果是一个hex值则直接返回
                var pattern = new RegExp("2[0-4]\\d|25[0-5]|[01]?\\d\\d?", "ig"); //这个正则是取 0 ~ 255的数字
                var va = v.match(pattern);
                if (va.length != 3) return "NaN"; //取出的数组长度一定得为3
                var result = "#";
                for (var i = 0; i < 3; i++)
                {
                    var num = parseInt(va[i]);
                    result += num < 16 ? "0" + num.toString(16) : num.toString(16); //如果小于F在前面补0
                }
                return result;
            },
            rgbToHexColor: function (r, g, b)
            {
                /// <summary>转换RGB颜色为16进制颜色</summary>

                return "#" + bxPub.parseInt(r, 0).toString(16).padLeft(2, "0") + bxPub.parseInt(g, 0).toString(16).padLeft(2, "0") + bxPub.parseInt(b, 0).toString(16).padLeft(2, "0");
            }
        }
    } ();
    //#endregion

    //#region Bx.String字符串类
    Bx.String = bxString = function ()
    {
        /// <summary>谷木人字符串操作方法集</summary>
        return {
            makeString: function (childString, number)
            {
                /// <summary>生成一个字符串</summary>
                /// <param name="childString">生成新字符串的组成字符串</param>
                /// <param name="number">生成长度,即子子符串长度的number倍</param>
                var l = childString.length;
                var s = "";
                for (var i = 0; i < number; i++) { s += childString; }
                return s;
            },
            getExtentsion: function (path, isWithPoint)
            {
                /// <summary>获取路径中的文件扩展名</summary>
                /// <param name="path">路径字符串</param>
                /// <param name="isWithPoint">是否包含点号".",默认包含</param>
                if (isWithPoint || isWithPoint == null)
                {
                    return path.substring(path.lastIndexOf("."));
                }
                else
                {
                    return path.substring(path.lastIndexOf(".") + 1);
                }
            },
            replace: function (source, search, newstr)
            {
                /// <summary></summary>
                var reg = new RegExp("\\" + search, "g");
                return source.replace(reg, newstr);

            }
        }
    } ();
    //#endregion

    //#region  Bx.DateTime日期时间类
    Bx.DateTime = bxTimeHelper = function ()
    {
        /// <summary>日期时间处理助手，默认一周第一天为周一</summary>
        var config = { firstDayInWeek: 1//一周的第一天：1为星期1，7为周日
        }
        return {
            getConfig: function ()
            {
                /// <summary>配置相关</summary>
                return config;
            },
            getMonthDay: function (year, month)
            {
                /// <summary>查询指定月的天数</summary>
                var solarMonth = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
                if (month == 2)
                {
                    return (((year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0)) ? 29 : 28);
                }
                else
                {
                    return (solarMonth[month - 1]);
                }
            },
            getCalendarMonth: function (year, month)
            {
                /// <summary>查询月的日历表，返回一个二维数组，格式为[[dtstart1,dtend1],[dtstart2,dtend2]...]</summary>
                var weeks = new Array();
                var d = bxTimeHelper.getMonthDay(year, month); //查询该月的天数
                weeks.push([new Date(year + "/" + month + "/1")]);
                for (var i = 1; i <= d; i++)
                {
                    var dtDay1 = new Date(year + "/" + month + "/" + i); //获取选择年月的指定号
                    var tempnum = dtDay1.getDay(); //获取选择日期的星期几，0表示日
                    if (((config.firstDayInWeek == 1) && (tempnum == 0)) || ((config.firstDayInWeek == 7) && (tempnum == 6)) || i == d)
                    {

                        weeks[weeks.length - 1].push(dtDay1); //本周的最后一天
                        if (i < d)
                        {
                            weeks.push([new Date(dtDay1.getYear(), dtDay1.getMonth(), i + 1)]);
                        }
                    }
                }
                return weeks;
            },
            getWeek: function (d)
            {
                /// <summary>查询指定日期所在周的起始和终止日期，返回格式为{startdate:Date,enddate:Date}</summary>
                /// <param name="d">查询的日期，Date对象</param>
                var dayOfWeek = d.getDay();
                if (dayOfWeek == 0) { dayOfWeek = 7; }
                var sDate = new Date(d), eDate = new Date(d);
                sDate.addDays(1 - dayOfWeek);
                eDate.addDays(7 - dayOfWeek);
                return { startdate: sDate, enddate: eDate };
            },
            getWeekDay: function (d)
            {
                /// <summary>返回星期的中文形式</summary>
                var i = d.getDay();
                var as = new Array("日", "一", "二", "三", "四", "五", "六");
                return as[i];
            },
            getWeekInMonth: function (d)
            {
                /// <summary>查询指定日期在该月中的第几周</summary>
                /// <param name="d">要查询的日期</param>
                var weeks = bxTimeHelper.getCalendarMonth(d.getYear(), d.getMonth() + 1);
                var dInMonth = d.getDate();
                for (var i = 0; i < weeks.length; i++)
                {
                    //bxAlert(weeks[i][0].getDate(), weeks[i][1].getDate());
                    if ((dInMonth >= weeks[i][0].getDate()) && (dInMonth <= weeks[i][1].getDate()))
                    {
                        return i + 1;
                    }
                }
                return -1;
            },
            getMonthWeek: function (year, month, weekIndex)
            {
                /// <summary>返回月的指定周的起始和截止日期，返回格式{startdate:,enddate:}</summary>
                /// <param name="year">要查询月的年</param>
                /// <param name="month">要查询的自然月，从1开始</param>
                /// <param name="weekIndex">要查询的周，从1开始</param>
                var d1 = new Date(year + "/" + month + "/1");
                var week1End = bxTimeHelper.getWeek(d1).enddate.getDate(); //第一周最后一天
                var r = {};
                if (weekIndex == 1)
                {
                    r.startdate = new Date(year + "/" + month + "/1");
                    r.enddate = new Date(year + "/" + month + "/" + week1End);
                }
                else
                {
                    r.startdate = new Date(year + "/" + month + "/" + (week1End + 1 + (weekIndex - 2) * 7));
                    var ed = r.startdate.getDate() + 6;
                    if (ed <= bxTimeHelper.getMonthDay(year, month))
                    {
                        r.enddate = new Date(year, month - 1, ed);
                    }
                    else
                    {
                        r.enddate = new Date(year, month - 1, bxTimeHelper.getMonthDay(year, month));
                    }
                }
                return r;

            },
            parseSenconds: function (senconds)
            {
                /// <summary>把秒数转换为时分秒对象</summary>
                /// <param name="senconds">总秒数</param>
                ///#region 
                var r = { h: 0, m: 0, s: 0 };
                r.h = Math.floor(senconds / 3600);
                r.m = Math.floor((senconds - 3600 * r.h) / 60);
                r.s = senconds - r.h * 3600 - r.m * 60;
                return r;
                ///#endregion 

            },
            getAge: function (birthday)
            {
                /// <summary>计算生日</summary>
                /// <param name="birthday">生日，日期格式或字符串格式</param>
                var d = new Date(birthday);
                var dn = new Date();
                var y = dn.getFullYear() - d.getFullYear();
                if (dn.getMonth() < d.getMonth()) { y--; }
                else if (dn.getMonth() > d.getMonth()) { }
                else { y = y - (dn.getDate() < d.getDate() ? 1 : 0); }
                return y;
            },
            getTimeSpan: function (dt1, dt2, valueFromat)
            {
                /// <summary>计算dt1-dt2的值，并返回该值{y,M,d,h,m,s}</summary>               
                var ts = bxParseInt((dt1 - dt2) / 1000, 1);
                var v = valueFromat || { d: 0, h: 0, m: 0, s: 0, ts: 0 };
                v.ts = ts;
                v.d = bxParseInt(ts / 86400, 0);
                ts = ts - v.d * 86400;
                v.h = bxParseInt(ts / 3600, 0);
                ts = ts - v.h * 3600;
                v.m = bxParseInt(ts / 60, 0);
                ts = ts - v.m * 60;
                v.s = bxParseInt(ts, 0);
                return v;
            }

        }
    } ();
    //#endregion 

    //#region Bx.Cookie Cookie类
    Bx.Cookie = new Object();
    Bx.Cookie.Add = function (name, value, expirestime)
    {
        /// <summary>添加Cookie</summary>
        /// <param name="name">名称</param>
        /// <param name="value">值</param>
        /// <param name="expirestime">超时时间,单位分钟,默认值为0,为0时表示随浏览器进程</param>
        var str = name + "=" + escape(value);
        if (expirestime > 0)
        {//为0时不设定过期时间，浏览器关闭时cookie自动消失
            var date = new Date();
            var ms = expirestime * 60 * 1000;
            date.setTime(date.getTime() + ms);
            str += "; expires=" + date.toGMTString();
        }
        document.cookie = str;
        return true;

    }
    Bx.Cookie.GetValue = function (name)
    {
        /// <summary>获取Cookie值</summary>
        /// <param name="name">名称</param>
        var arrStr = document.cookie.split("; ");
        for (var i = 0; i < arrStr.length; i++)
        {
            var temp = arrStr[i].split("=");
            if (temp[0] == name) return unescape(temp[1]);
        }
        return "";
    }
    Bx.Cookie.Delete = function (name)
    {
        /// <summary>删除指定Cookie</summary>
        /// <param name="name">名称</param>
        var date = new Date();
        date.setTime(date.getTime() - 10000);
        document.cookie = name + "=a; expires=" + date.toGMTString();
    }
    //#endregion

    //#region Bx.Style样式类
    Bx.Style = bxStyle = function ()
    {
        return {
            setImgNoPic: function (obj, nopicUrl)
            {
                /// <summary>设置IMG标签没有图上或加载错误时的默认图片</summary>
                var src = obj.attributes["src"].value;
                if (src == "" || src.indexOf(".html") > 0 || src.substr(src.length - 1) == "/") { obj.src = nopicUrl; }
                else { obj.onerror = function () { obj.src = nopicUrl; bxFixPng(obj); } }
            },
            xy: function (obj)
            {
                /// <summary>返回或设置对象基于页面的坐标</summary>
                var obj = $(obj), _xy = { x: obj.offsetLeft, y: obj.offsetTop }, pn = obj;
                while (pn = pn.offsetParent)
                {
                    _xy.y += pn.offsetTop;
                    _xy.x += pn.offsetLeft;
                }
                return _xy;
            },
            addCss: function (cssText)
            {
                /// <summary>向页面添加一段样式</summary>
                var s = document.createElement("style");
                s.type = "text/css";
                if (bxNavigator.IsIE)
                {
                    s.styleSheet.cssText = cssText;
                }
                else
                {
                    var frag = document.createDocumentFragment();
                    frag.appendChild(document.createTextNode(cssText));
                    s.appendChild(frag);
                }
                $T("head")[0].appendChild(s);
            },
            addClassName: function (obj, className)
            {
                /// <summary>添加元素的指定类名</summary>
                var className = className.trim();
                if (!bxCheckCssName(obj, className)) { obj.className += (" " + className); }
            },
            removeClassName: function (obj, className)
            {
                /// <summary>删除元素的指定类名</summary>
                var className = className.trim();
                obj.className = obj.className.replace(eval("/ " + className + "|" + className + " /"), "");
            }
        }
    } ();
    Bx.Style.GetBodyDocumentElement = bxGetBodyDocumentElement = function (windowobj)
    {
        /// <summary>根据当前所有标准自动获取Body对象或DocumentElement对象</summary>
        /// <param name="windowobj">包含document的window对象，默认为当前页面的window对象</param>
        var doc = windowobj ? windowobj.document : document;
        return doc.compatMode == "CSS1Compat" ? doc.documentElement : doc.body;
    }
    Bx.Style.GetRuntimeStyle = bxGetRuntimeStyle = function (obj, propertyName)
    {
        /// <summary>获取对象运行时的样式属性值,包括内联和外联CSS属性值</summary>
        /// <param name="obj">要获取属性值的对象</param>
        /// <param name="propertyName">CSS属性名称，兼容Javascript属性名称</param>
        var v = null;
        var propertyName = bxNavigator.IsFireFox ? propertyName.replace(/([A-Z])/g, function (a) { return "-" + a.toLowerCase(); }) : propertyName.replace(/(-\w)/g, function (a) { return (a.substring(1, 2).toUpperCase()); });
        try
        {
            if (obj.currentStyle) { v = obj.currentStyle[propertyName]; } else { v = window.getComputedStyle(obj, null).getPropertyValue(propertyName); } return v;
        }
        catch (e) { return ""; }
    }
    Bx.Style.GetBoxInfo = bxGetBoxInfo = function (obj)
    {
        /// <summary>查询盒子模型信息值，返回值为：{left:px,top:px,width:px,height:px,border:{top:px,left:px,right:px,bottom:px},margin:{top:px,left:px,right:px,bottom:px}}</summary>
        /// <param name="obj">要查询的对象</param>
        var obj = $(obj);
        var r = new Object();
        r.border = new Object();
        r.border.top = parseInt(obj.css("border-top-width")); if (isNaN(r.border.top)) { r.border.top = 0; }
        r.border.left = parseInt(obj.css("border-left-width")); if (isNaN(r.border.left)) { r.border.left = 0; }
        r.border.right = parseInt(obj.css("border-right-width")); if (isNaN(r.border.right)) { r.border.right = 0; }
        r.border.bottom = parseInt(obj.css("border-bottom-width")); if (isNaN(r.border.bottom)) { r.border.bottom = 0; }
        r.padding = new Object();
        r.padding.top = parseInt(obj.css("padding-left")); if (isNaN(r.padding.top)) { r.padding.top = 0; }
        r.padding.right = parseInt(obj.css("padding-right")); if (isNaN(r.padding.right)) { r.padding.right = 0; }
        r.padding.left = parseInt(obj.css("padding-left")); if (isNaN(r.padding.left)) { r.padding.left = 0; }
        r.padding.bottom = parseInt(obj.css("padding-bottom")); if (isNaN(r.padding.bottom)) { r.padding.bottom = 0; }
        r.left = obj.offsetLeft;
        r.top = obj.offsetTop;
        r.width = obj.offsetWidth - r.padding.left - r.padding.right - r.border.left - r.border.right;
        r.height = obj.offsetHeight - r.padding.top - r.padding.bottom - r.border.top - r.border.bottom;
        return r;
    }
    Bx.Style.GetBackgroundImageUrl = function (obj)
    {
        /// <summary>获取指定对象或url形式字符串中的背景图片路径</summary>
        /// <param name="obj">获取对象,可为对象类型或字符串,字符串须为url(...)格式</param>
        if (typeof (obj) == "object") { obj = obj.css("background-image"); }
        return obj.replace(/url|\(|\)|'|"/ig, "");
    }
    Bx.Style.GetClassNames = function (obj)
    {
        /// <summary>获取标签对象的CSS类名称数组</summary>
        /// <param name="obj">对象表达式</param>
        obj = $(obj);
        var name = obj.className.split(/ +/);
        var cns = new Array();
        for (var i = 0; i < name.length; i++)
        {
            if (name[i] != "" && name[i] != " ")
            {
                cns[cns.length] = name[i];
            }
        }
        return cns;
    }
    Bx.Style.GetObjTopY = function (obj)
    {
        /// <summary>获取对象顶部相对于网页左上角的Y坐标</summary>
        return $(obj).xy().y;
    }
    Bx.Style.GetObjLeftX = function (obj)
    {
        /// <summary>获取对象左侧相对于网页左上角的X坐标</summary>
        return $(obj).xy().x;
    }

    Bx.Style.SetAlignCenterInParent = function (obj, type)
    {
        /// <summary>设置对象居于父窗口中间</summary>
        /// <param name="obj">要居中的对象</param>
        /// <param name="type">居中方式,可取值为"x","y","both",默认both</param>
        var obj = $(obj);
        var pw = obj.parentNode.offsetWidth;
        var ph = obj.parentNode.offsetHeight;
        var pos = Bx.Style.GetRuntimeStyle(obj, "position");

        if (pos == "static")
        {
            //obj.style.position = "relative";
            return;
        }
        var tw = obj.offsetWidth;
        var th = obj.offsetHeight;
        if (type == "y" || type == "both")
        {
            obj.style.top = (ph / 2 - th / 2) + "px";

        }
        if (type == "x" || type == "both")
        {
            obj.style.left = "50%";
            obj.style.marginLeft = (-1 * tw / 2) + "px";
        }
    }
    Bx.Style.SetAlignCenterInWindow = function (obj, type)
    {
        /// <summary>设置对象居于浏览器窗口中间</summary>
        /// <param name="obj">要居中的对象</param>
        /// <param name="type">居中方式,可取值为"x","y","both",默认both</param>
        obj = $(obj);
        var winHeight, winWidth, winLeft, winTop;
        var oWidth = obj.offsetWidth, oHeight = obj.offsetHeight;
        var objBody = Bx.Style.GetBodyDocumentElement();
        winHeight = objBody.clientHeight;
        winWidth = objBody.clientWidth;
        winLeft = objBody.scrollLeft, winTop = objBody.scrollTop;

        if (type == "x" || type == "both" || type == null)
        {
            obj.style.left = winLeft + winWidth / 2 - oWidth / 2 + "px";
        }
        if (type == "y" || type == "both" || type == null)
        {
            obj.style.top = winTop + winHeight / 2 - oHeight / 2 + "px";
        }
        if (obj.getAttribute("SetAlignCenterInWindow"))
        {
            if (obj.parentNode.parentNode == null)
            {
                var o = obj.getAttribute("SetAlignCenterInWindow");
                window.SetAlignCenterInWindowArray.Remove(o);
                Bx.Sys.RemoveEvent(window, "onresize", o);
                obj.setAttribute("SetAlignCenterInWindow", false);
            }
        }
        else
        {
            if (!window.SetAlignCenterInWindowArray)
            {
                window.SetAlignCenterInWindowArray = new Array();
            }
            var f = window.SetAlignCenterInWindowArray[window.SetAlignCenterInWindowArray.length] = function ()
            {
                Bx.Style.SetAlignCenterInWindow(obj, type);
            }
            Bx.Sys.AddEvent(window, "onresize", f);
            obj.setAttribute("SetAlignCenterInWindow", f);


        }
    }
    Bx.Style.SetPostionInWindow = function (obj, left, top, right, bottom)
    {
        /// <summary>设置对象相对于浏览器窗口的位置</summary>
        /// <param name=""></param>
        /// <param name=""></param>
        /// <param name=""></param>
        /// <param name=""></param>
        var winLeft, winTop;
        var bd = bxGetBodyDocumentElement();
        winLeft = bd.scrollLeft, winTop = bd.scrollTop;
        obj = $(obj);
        if (left != null)
        {
            obj.style.left = left + winLeft + "px";
        }
        if (top != null)
        {
            obj.style.top = top + winTop + "px";
        }

    }

    bxFixPng = function (srcElement, isAuto)
    {
        /// <summary>修复IE6下标签的图片PNG</summary>
        /// <param name="imgObj">修正标签</param>
        /// <param name="isAuto">默认True:自动判断扩展名并修复，False:强制修复</param>
        if (bxNavigator.IsIE6 && bxPlugin.run("ie6fix")) { bxIe6Png.fixSrc(srcElement); bxIe6Png.fixBackground(srcElement); }
    }
    Bx.Style.ShowBodyInfo = function ()
    {
        var bd = Bx.Style.GetBodyDocumentElement();
        var s = "";
        s += "\r\n网页可见区域宽：" + bd.clientWidth;
        s += "\r\n网页可见区域高：" + bd.clientHeight;
        s += "\r\n网页可见区域宽：" + bd.offsetWidth + "  (包括边线的宽)";
        s += "\r\n网页可见区域高：" + bd.offsetHeight + "  (包括边线的宽)";
        s += "\r\n网页正文全文宽：" + bd.scrollWidth;
        s += "\r\n网页正文全文高：" + bd.scrollHeight;
        s += "\r\n网页被卷去的高：" + bd.scrollTop;
        s += "\r\n网页被卷去的左：" + bd.scrollLeft;
        s += "\r\n网页正文部分上：" + window.screenTop;
        s += "\r\n网页正文部分左：" + window.screenLeft;
        s += "\r\n屏幕分辨率的高：" + window.screen.height;
        s += "\r\n屏幕分辨率的宽：" + window.screen.width;
        s += "\r\n屏幕可用工作区高度：" + window.screen.availHeight;
        s += "\r\n屏幕可用工作区宽度：" + window.screen.availWidth;
        alert(s);
    }
    Bx.Style.SetAlpha = bxSetAlpha = function (obj, opacityValue)
    {
        /// <summary>设置标签对象透明度</summary>
        /// <param name="obj">要设置的标签对象</param>
        /// <param name="opacityValue">透明值,0~100</param>
        var obj = $(obj);
        if (bxNavigator.IsIE)
        {
            var f = obj.filters["alpha"];
            f = f ? f : obj.filters["progid:DXImageTransform.Microsoft.Alpha "];
            if (f) { if (opacityValue >= 0) { f.enabled = true; f.opacity = opacityValue; } else { f.enabled = false; } }
            else if (opacityValue >= 0) { obj.style.filter = (bxGetRuntimeStyle(obj, "filter") + " " + " alpha(opacity=" + opacityValue + ")").trim(); }
        }
        else
        {
            opacityValue = opacityValue / 100;
            obj.style.opacity = opacityValue >= 0 ? opacityValue : 1;
        }
    }
    Bx.Style.SetWindowAlpha = function (opacityValue, colorValue, windowSet, features)
    {
        /// <summary>设置整个屏幕窗口的透明度,即使网页变暗</summary>
        /// <param name="opacityValue">透明值,0~100</param>
        /// <param name="colorValue">原始颜色值，默认为透明色Transparent</param>
        /// <param name="windowSet">要设置的window对象，默认为window.top即顶层窗口</param>
        var cv;
        if (colorValue)
        {
            cv = colorValue;
        }
        else
        {
            cv = "Transparent";
        }
        var pw = windowSet ? windowSet : window.top, dmt = pw.document, pnode = dmt.body;
        if (bxNavigator.IsIE8 || bxNavigator.IsIE9 || Bx.Navigator.Info.IsFireFox) { pnode = dmt.body.parentNode; }
        var aDiv = dmt.createElement("div");
        if (bxNavigator.IsIE)
        {
            aDiv.style.cssText = "position:absolute;top:0px;left:0px ;width:100%;height:100%;bottom:0px;margin-bottom:0px;background-color:" + cv + ";filter:alpha(opacity=" + opacityValue + "); ";
        }
        else
        {
            aDiv.style.cssText = "position:absolute;top:0px;left:0px ;width:100%;height:100%;bottom:0px;background-color:" + cv + ";-moz-opacity:" + opacityValue / 100 + ";opacity:" + opacityValue / 100 + " ;";
        }
        //aDiv.style.height = pnode.scrollHeight + "px";
        //aDiv.style.width = pnode.scrollWidth + "px";
        aDiv.funResize = function ()
        {
            aDiv.style.height = pnode.scrollHeight + "px";
            aDiv.style.width = pnode.scrollWidth + "px";
        }
        pnode.appendChild(aDiv);
        aDiv.w = pw;
        SysAddEvent(pw, "onresize", aDiv.funResize);
        aDiv.funResize();
        var childs = pnode.childNodes;
        var z = 999;
        var max = bxGetProperty(features, "maxdepth", 9000);
        for (var i = 0; i < childs.length; i++)
        {
            var z2 = parseInt(bxGetRuntimeStyle(childs[i], "z-index"));
            if (z2 != NaN && z2 >= z && z2 <= max)
            {
                z = z2 + 1;
            }
        }
        aDiv.style.zIndex = z;
        //修复IE6 Select Bug
        if (bxNavigator.IsIE6)
        {
            var sels = $T("select", document.body);
            for (var i = 0; i < sels.length; i++)
            {
                var sel = sels[i];
                if (bxGetRuntimeStyle(sel, "visibility") != "hidden") { sel.isbxalpha = bxGetRuntimeStyle(sel, "visibility"); sel.style.visibility = "hidden"; }
            }
        }
        return aDiv;
    }

    Bx.Style.ClearWindowAlpha = function (alphaObj)
    {
        /// <summary>消除由SetWindowAlpha方法设置的屏幕透明度</summary>
        /// <param name="alphaObj">由SetWindowAlpha方法返回的句柄对象</param>

        var obj = $(alphaObj);
        if (obj.funResize)
        {
            SysRemoveEvent(obj.w, "onresize", obj.funResize);
            //obj.funResize = null;
        }
        if (obj)
        {
            obj.parentNode.removeChild(obj);
        }
        //修复IE6 Select Bug
        if (Bx.Navigator.Info.IsIE6)
        {
            var sels = $T("select", document.body);
            for (var i = 0; i < sels.length; i++)
            {
                var sel = sels[i];
                if (sel.isbxalpha) { sel.style.visibility = sel.isbxalpha; sel.isbxalpha = null; }
            }
        }
        obj = null;
    }
    Bx.Style.CheckCssName = bxCheckCssName = function (obj, cssName)
    {
        /// <summary>检测对象是否具有指定Css类名</summary>
        var obj = $(obj);
        if (obj.className)
        {
            return obj.className.split(" ").indexOf(cssName) >= 0;
        }
        return false;
    }
    //#endregion

    //#region Bx.MessageBox 模拟对话框
    bxOpenWindow = function (title, url, windowStyle, closeStyle, feature, closeFunction, showWindow)
    {
        /// <summary>打开一个模拟窗口,内容为指定的URL</summary>
        /// <param name="url">要打开的页面URL</param>
        /// <param name="title">窗口标题</param>
        /// <param name="feature">窗口特征</param>
        /// <param name="showWindow">加载window对象</param>             
        if (bxPlugin.run("messagebox"))
        {
            return Bx.MessageBox.OpenWindow(title, url, windowStyle, closeStyle, feature, closeFunction, showWindow);
        }
        else
        {
            return null;
        }
    }
    bxCloseOpenWindow = function (index)
    {
        /// <summary>关闭由 Bx.MessageBox.OpenWindow 即 bxOpenWindow 打开的窗口</summary>
        /// <param name="index">要关闭的窗口索引，默认为当前的页面窗口</param>
        if (bxPlugin.run("messagebox")) { Bx.MessageBox.CloseOpenWindow(index); }

    }
    //#endregion

    //#region Bx.Ajax BxAjax类
    Bx.Ajax = bxAjax = function ()
    {
        function ajax()
        {
            /// <summary>Ajax对象</summary>
            var newAjax = bxAjax.getXmlHttpRequest();
            var requestUrl = "", requestAsync = true, userName = "", userPassword = "", contentType = "application/x-www-form-urlencoded";
            var returnCall = function ()
            {
                /// <summary>回调函数,如果执行是状态正常，那么就把返回的内容赋值给上面指定的层</summary>
                if (newAjax.readyState == 4 && newAjax.status == 200) { readyFunction(); }
            }
            var readyFunction = function ()
            {
                /// <summary>默认加载完成处理函数</summary>
            }
            var thisObj = this;
            return {
                setContentType: function (value)
                {
                    /// <summary>设置针对Send()方法的Content-type值,执行该方法将返回设置之前的值</summary>
                    /// <param name="value">要设置的值,默认为"application/x-www-form-urlencoded"</param>
                    var oldType = contentType;
                    if (value != null) { contentType = value; }
                    return oldType;
                },
                setCallFunction: function (callFunction)
                {
                    /// <summary>设置回调函数</summary>
                    returnCall = callFunction;
                },
                setReadyFunction: function (readyCallFunction)
                {
                    /// <summary>设置加载完成后的处理函数,如果调用了SetCallFunction()方法设置了新的回调函数,本方法将不会起做用</summary>
                    /// <param name="readyCallFunction">加载完成后的处理函数</param>
                    if (readyCallFunction != null)
                    {
                        readyFunction = readyCallFunction;
                    }
                },
                open: function (url, callFunction, isAsync)
                {
                    /// <summary>AJAX对象的OPEN方法</summary>
                    /// <param name="url">请求的URL地址</param>
                    /// <param name="callFunction">回调函数,不指定本参数将采用默认回调函数</param>
                    /// <param name="isAsync">是否采用异步模式,默认采用异步</param>

                    if (typeof (url) == 'undefined')
                    {
                        return false;
                    }
                    requestUrl = url;
                    if (callFunction)
                    {
                        this.setCallFunction(callFunction);
                    }
                    if (isAsync != null)
                    {
                        requestAsync = isAsync;
                    }
                },
                close: function ()
                {
                    /// <summary>取消发送</summary>
                    newAjax.abort();
                },
                setUser: function (username, userpassword)
                {
                    /// <summary>设置用户名和密码,默认为空</summary>
                    if (username != null)
                    {
                        userName = username;
                        if (userpassword != null)
                        {
                            userPassword = userpassword;
                        }
                    }
                },
                send: function (value)
                {
                    /// <summary>发送</summary>

                    if (typeof (requestUrl) == 'undefined')
                    {
                        return false;
                    }
                    if (typeof (returnCall) == 'undefined')
                    {
                        return false;
                    }
                    if (typeof (value) == 'undefined')
                    {
                        //使用Get方式进行请求

                        if (typeof (userName) == 'undefined' || userName.length == 0)
                        {
                            newAjax.open("GET", requestUrl, requestAsync);
                        }
                        else
                        {
                            newAjax.open("GET", requestUrl, requestAsync, userName, userPassword);
                        }
                        newAjax.onreadystatechange = returnCall; //设置执行状态回调处理函数句柄
                        newAjax.send(null); //发送
                        if (bxNavigator.IsFireFox && !requestAsync)
                        {
                            returnCall();
                        }
                    }
                    else
                    { //使用POST方式进行请求
                        //alert("ok");
                        if (typeof (userName) == 'undefined' || userName.length == 0)
                        { newAjax.open("POST", requestUrl, requestAsync); }
                        else
                        {
                            newAjax.open("POST", requestUrl, requestAsync, userName, userPassword);
                        }
                        newAjax.onreadystatechange = returnCall; //设置执行状态回调处理函数句柄
                        newAjax.setRequestHeader("Content-Length", value.length);
                        newAjax.setRequestHeader("Content-type", contentType);
                        //newAjax.setRequestHeader("Content-type", "text/xml");
                        newAjax.send(value); //发送
                        if (bxNavigator.IsFireFox && !requestAsync)
                        {
                            returnCall();
                        }

                    }
                },
                sendXml: function (value)
                {
                    /// <summary>发送text/xml格式的数据</summary>
                    /// <param name="value">要发送的数据</param>

                    var conType = this.setContentType("text/xml");
                    this.send(value);
                    this.setContentType(conType);
                },
                getXmlHttpObject: function ()
                {
                    /// <summary>获取内部生成的XMLHttpRequest对象</summary>
                    return newAjax;
                },
                getResponseText: function ()
                {
                    /// <summary>获取客户端接收到的HTTP响应的文本内容</summary>    
                    return newAjax.responseText;
                },
                getResponseXML: function ()
                {
                    /// <summary>获取接收到完整的HTTP响应时(readyState为4)描述XML响应</summary>

                    return newAjax.responseXML;
                },
                getResponseBody: function ()
                {
                    /// <summary></summary>

                    return newAjax.responseBody;
                },
                getResponseStream: function ()
                {
                    return newAjax.responseStream;
                }
            }
        }

        return {
            getXmlHttpRequest: function ()
            {
                /// <summary>获取一个XmlHttpRequest对象,兼容各浏览器</summary>
                var name = false;
                try
                {
                    name = new ActiveXObject("Msxml2.XMLHTTP");

                }
                catch (e)
                {
                    try
                    {
                        name = new ActiveXObject("Microsoft.XMLHTTP");
                    }
                    catch (e)
                    {
                        if (typeof XMLHttpRequest != 'undefined')
                        {
                            try
                            {
                                name = new XMLHttpRequest();
                            }
                            catch (e)
                            {
                                if (window.createRequest)
                                {
                                    try
                                    {
                                        name = window.createRequest();
                                    }
                                    catch (e)
                                    {
                                        name = false;
                                    }
                                }
                            }
                        }
                    }
                }
                return name;
            },
            getAjaxInstance: function ()
            {
                /// <summary>获取一个Ajax操作对象实例</summary>
                var a = new ajax();
                return a;
            },
            getURL: function (url, funReceive, isAsync)
            {
                /// <summary>从指定URL用get方式获取数据</summary>
                /// <param name="url">请求的URL</param>
                /// <param name="funReceive">回调函数,function(response{stream,body,xml,text,ajax})</param>
                /// <param name="isAsync">是否是异步请求</param>

                var myAjax = new ajax();
                myAjax.setReadyFunction(function ()
                {
                    var response = {
                        stream: myAjax.getResponseStream(),
                        body: myAjax.getResponseBody(),
                        xml: myAjax.getResponseXML(),
                        text: myAjax.getResponseText(),
                        ajax: myAjax
                    }
                    funReceive(response);
                });
                var isAsync = isAsync == false ? false : true;
                myAjax.open(url, null, isAsync);
                myAjax.send();
            }
        }
    } ();
    bxPageAPI = function (apiPageUrl, method, arrayParamsSend, receiveFunction, featuresParams)
    {
        /// <summary>执行BxAPI请求</summary>
        /// <param name="apiPageUrl">接口页面地址，如果设为空则默认为本页面</param>
        /// <param name="method">请求的方法名称</param>    
        /// <param name="arrayParams">包含参数名称和参数值的数组</param>
        /// <param name="receiveFunction">返回执行函数</param>
        /// <param name="featuresParams">特征值参数对象</param>

        if (bxPlugin.run("xmlapi"))
        {
            Bx.XML.API.PageAPI(apiPageUrl, method, arrayParamsSend, receiveFunction, featuresParams);
        }
    }

    //#endregion

    //#region Bx.XML XML相关类
    Bx.XML = new Object();
    Bx.XML.LoadXmlFile = function (xmlFile)
    {
        /// <summary>加载XML文件,返回XmlDom对象</summary>
        /// <param name="xmlFile">加载的xml文件URI</param>

        var xmlDoc;
        if (window.ActiveXObject)
        {
            xmlDoc = new ActiveXObject('Microsoft.XMLDOM');
            xmlDoc.async = false;
            xmlDoc.load(xmlFile);
        }
        else if (document.implementation && document.implementation.createDocument)
        {
            xmlDoc = document.implementation.createDocument('', '', null);
            xmlDoc.async = false;
            xmlDoc.load(xmlFile);
        }
        else
        {
            return null;
        }
        return xmlDoc;
    }
    Bx.XML.LoadXmlString = function (xmlString)
    {
        /// <summary>从xml格式字符串中加载XmlDom对象</summary>
        /// <param name="xmlString">XML格式字符串</param>
        var xmlDoc;
        if (window.ActiveXObject)
        {
            xmlDoc = new ActiveXObject('Microsoft.XMLDOM');
            xmlDoc.async = false;
            xmlDoc.loadXML(xmlString);
        }
        else if (document.implementation && document.implementation.createDocument)
        {
            var oParser = new DOMParser();
            var xmlDoc = oParser.parseFromString(xmlString, "text/xml");
        }
        else
        {
            return null;
        }
        return xmlDoc;
    }
    /**
    * Xml解析助手
    */
    if (!bxNavigator.IsIE)
    {
        try
        {
            XMLDocument.prototype.selectNodes = function (cXPathString, xNode)
            {
                if (!xNode) { xNode = this; }
                var oNSResolver = this.createNSResolver(this.documentElement)
                var aItems = this.evaluate(cXPathString, xNode, oNSResolver,
                   XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null)
                var aResult = [];
                for (var i = 0; i < aItems.snapshotLength; i++)
                {
                    aResult[i] = aItems.snapshotItem(i);
                }
                return aResult;
            }
            // prototying the Element
            Element.prototype.selectNodes = function (cXPathString)
            {
                if (this.ownerDocument.selectNodes)
                {
                    return this.ownerDocument.selectNodes(cXPathString, this);
                }
                else { throw "For XML Elements Only"; }
            }
            // prototying the XMLDocument
            XMLDocument.prototype.selectSingleNode = function (cXPathString, xNode)
            {
                if (!xNode) { xNode = this; }
                var xItems = this.selectNodes(cXPathString, xNode);
                if (xItems.length > 0)
                {
                    return xItems[0];
                }
                else
                {
                    return null;
                }
            }
            // prototying the Element
            Element.prototype.selectSingleNode = function (cXPathString)
            {
                if (this.ownerDocument.selectSingleNode)
                {
                    return this.ownerDocument.selectSingleNode(cXPathString, this);
                }
                else { throw "For XML Elements Only"; }
            }

            XMLDocument.prototype.transformNode = function (styleDocument)
            {
                var xslProc = new XSLTProcessor();
                xslProc.importStylesheet(styleDocument);
                //alert(styleDocument.xml);
                var mDoc = xslProc.transformToFragment(this, document);
                return mDoc.xml;
            }
            Element.prototype.transformNode = function (styleDocument)
            {
                var xslProc = new XSLTProcessor();
                xslProc.importStylesheet(styleDocument);
                //alert(styleDocument.xml);
                //var mDoc=xslProc.transformToDocument(xDoc);
                var mDoc = xslProc.transformToFragment(this, document);
                return mDoc.xml;
            }

            XMLDocument.prototype.__defineGetter__("xml", function ()
            {
                var xmlStr;
                try
                {
                    xmlStr = new XMLSerializer().serializeToString(this);
                }
                catch (ex)
                {
                    var d = document.createElement(" div ");
                    d.appendChild(this.cloneNode(true));
                    xmlStr = d.innerHTML;
                }
                var re = / encoding=\"UTF-8\"/g
                xmlStr = xmlStr.replace(re, "");
                return xmlStr;
            });
            Element.prototype.__defineGetter__("xml", function ()
            {
                var xmlStr;
                try
                {
                    xmlStr = new XMLSerializer().serializeToString(this);
                }
                catch (ex)
                {
                    var d = document.createElement(" div ");
                    d.appendChild(this.cloneNode(true));
                    xmlStr = d.innerHTML;
                }
                var re = / encoding=\"UTF-8\"/g
                xmlStr = xmlStr.replace(re, "");
                return xmlStr;
            });
            DocumentFragment.prototype.__defineGetter__("xml", function ()
            {
                var xmlStr;
                try
                {
                    xmlStr = new XMLSerializer().serializeToString(this);
                }
                catch (ex)
                {
                    var d = document.createElement(" div ");
                    d.appendChild(this.cloneNode(true));
                    xmlStr = d.innerHTML;
                }
                var re = / encoding=\"UTF-8\"/g
                xmlStr = xmlStr.replace(re, "");
                return xmlStr;
            });

            XMLDocument.prototype.__defineGetter__("text", function ()
            {
                return this.firstChild.textContent;
            });
            Element.prototype.__defineGetter__("text", function ()
            {
                return this.textContent;
            });
        }
        catch (e) { }
    }
    //#endregion

    //#region Bx.Validator验证控件
    bxValSetMessage = function (varControl, isOk, message)
    {
        /// <summary>设置验证控件消息及状态</summary>
        /// <param name="varControl">要设置的验证的控件</param>
        /// <param name="isOk">设置状态为True：通过验证，Fasle：未通过验证，null：未进行验证</param>
        /// <param name="message">消息文本</param>
        bxPlugin.run("validator", function ()
        {
            Bx.Validator.SetMessage(varControl, isOk, message);
        });
    }
    bxValMessage = "";
    bxVal = function (groupname)
    {
        /// <summary>验证指定组控件，通过验证返回True，反之返回False</summary>
        if (bxPlugin.run("validator"))
        {
            return Bx.Validator.ValidateControls(groupname);
        }
        return false;
    }
    bxValInit = function ()
    {
        /// <summary>初始化验证控件</summary>    
        if (bxPlugin.run("validator"))
        {
            Bx.Validator.Init();
        }
    }
    //#endregion

    //#region Bx.Controls控件类
    Bx.Controls = new Object();
    Bx.Controls.TextSetRemark = bxTextSetRemark = function (objOrId, remarkString, isAutoHide, options)
    {
        /// <summary>设置文本框的提示内容信息</summary>
        /// <param name="objOrId">要设置的文本框对象为ID</param>
        /// <param name="remarkString">提示内容</param>
        /// <param name="isAutoHide">当获得焦点时是否自动隐藏,设为False时将会自动把文本设为选中状态;设为True时则会自动清空文本</param>
        /// <param name="options">{color:gray[默认颜色值],setDefaultValue:true[是否设置默认值]}</param>

        var obj = $(objOrId);
        obj.value = remarkString;
        var options = options || {};
        var oldColorr = Bx.Style.GetRuntimeStyle(obj, "color")
        obj.setAttribute("oldFontColor", oldColorr);
        obj.style.color = options.p("color", "gray");
        if (options.p("setDefaultValue", true))
        {
            obj.defaultValue = remarkString;
        }
        if (isAutoHide)
        {
            SysAddEvent(obj, "onfocus", function () { if (obj.value == remarkString) obj.value = ''; obj.style.color = obj.getAttribute("oldFontColor"); });
        }
        else
        {
            SysAddEvent(obj, "onfocus", function () { obj.select(); });
        }
        SysAddEvent(obj, "onblur", function () { if (obj.value == '') { obj.value = remarkString; obj.style.color = bxGetProperty(options, "color", "gray"); } });
    }
    Bx.Controls.Select = bxSelect = function ()
    {
        return {
            getSelectedOption: function (selObj)
            {
                /// <summary>返回当前选择项对象</summary>
                return selObj.options[selObj.selectedIndex];
            }
        }
    } ();

    Bx.Controls.SelectAddOption = bxSelectAddOption = function (selObj, value, text)
    {
        /// <summary>向下拉列表框增加一个项</summary>
        /// <param name="selObj">要操作的列表框控件</param>
        /// <param name="value">值</param>
        /// <param name="text">文本</param>

        var sel = $(selObj);
        if (!sel) { return false; }
        var y = document.createElement('option');
        y.value = value;
        y.text = text;

        try
        {
            sel.add(y, null); // standards compliant
        }
        catch (ex)
        {
            sel.add(y); // IE only
        }
    }
    Bx.Controls.SelectSetOptions = bxSelectSetOptions = function (selObj, params)
    {
        /// <summary>设置下拉选择框的选项</summary>
        /// <param name="selObj">要设置的选择框对象</param>
        /// <param name="params">如果该参数系统为一个数组参数，则该数组的奇数位为值，偶数位为文本；如果该参数系列为两个数组参数，则第一个为值数组，第二个为文本数组；如果该参数系列为1个字符串，则使用逗号分隔符计算；如果为多个参数，则奇数位为值，偶数位为文本</param>
        var sel = $(selObj);
        if (!sel) { return false; }
        sel.options.length = 0;
        if (arguments.length == 1 || params == null) { return false; }
        else if (arguments.length == 2 && params.constructor == window.Array)
        {
            for (var i = 0; i + 1 < params.length; i = i + 2)
            {
                bxSelectAddOption(sel, params[i], params[i + 1]);
            }

        }
        else if (arguments.length == 3 && params.constructor == window.Array && arguments[2].constructor == window.Array)
        {
            var m = Math.min(params.length, arguments[2].length);
            for (var i = 0; i < m; i++)
            {
                bxSelectAddOption(sel, params[i], arguments[2][i]);
            }
        }
        else if (arguments.length == 2 && typeof (params) == "string")
        {
            var as = params.split(",");
            for (var i = 0; i + 1 < as.length; i = i + 2)
            {
                bxSelectAddOption(sel, as[i], as[i + 1]);
            }
        }
        else if (arguments.length >= 3)
        {
            for (var i = 1; i + 1 < arguments.length; i = i + 2)
            {
                bxSelectAddOption(sel, arguments[i], arguments[i + 1]);
            }
        }
        else
        {
            return false;
        }
        return true;
    }
    Bx.Controls.RadioGetValue = bxRadioGetValue = function (name, defaultValue)
    {
        /// <summary>获取radio控件的值</summary>
        /// <param name="name">name值</param>
        /// <param name="defaultValue">如果没有选择项时的默认返回值</param>
        var rs = $N(name);
        for (var i = 0; i < rs.length; i++)
        {
            var obj = rs[i];
            if (obj.checked) { return obj.value; }
        }
        if (defaultValue != null) { return defaultValue; } else { return null; }
    }
    Bx.Controls.TextAreaAutoHeight = bxTextAreaAutoHeight = function (obj)
    {
        /// <summary>设置textarea控件根据内容自动调整高度以不出现滚动条</summary>
        /// <param name="obj">要设置的对象</param>
        var obj = $(obj);
        SysAddEvent(obj, "onpropertychange", function () { obj.style.posHeight = obj.scrollHeight; });
        SysAddEvent(obj, "onfocus", function () { obj.style.posHeight = obj.scrollHeight; });
    }
    //#endregion    

    //#region Bx.Motion 动画操作
    bxMotion = function ()
    {
        /// <summary>动画操作集</summary>
        return {
            tween: function (obj, attributes, options)
            {
                /// <summary>创建补间动画</summary>
                /// <param name="obj">需要动画的对象</param>
                /// <param name="attributes">动画参数集合对象，包括{ css 名称:{from:初使值,to:结束值}...}{"width":{to:100},"height":{to:100}} //同时将对象的width与height从当前值扩大到100px</param>
                /// <param name="options">参数集合包括{currentTime: 0, //时间初使化,默认值为0,无需改动;duration: 100, //持续时间,值越大,动画速度越慢tweenType: "Linear", //Tween类型(缓动类型)easeType: "easeIn", //Tween缓动类型,配合tweenType属性onStart: null, //动画开始时触发事件 onEnd: null //动画结束后触发事件}</param>

                var tw;
                bxPlugin.run("motion", function ()
                {
                    tw = new Bx.Motion.Tween();
                    tw.init(obj, attributes, options);
                });
                return {
                    play: function ()
                    {
                        /// <summary>播放动画</summary>
                        tw.play();
                    },
                    stop: function ()
                    {
                        /// <summary>停止动画</summary>
                        tw.stop();
                        tw = null;
                    },
                    resume: function ()
                    {
                        /// <summary>恢复动画执行</summary>
                        tw.resume();
                    },
                    pause: function ()
                    {
                        /// <summary>暂停动画执行</summary>
                        tw.pause();
                    }
                };
            },
            drag: function (obj, options)
            {
                var dg;
                bxPlugin.run("motion", function ()
                {
                    dg = new Bx.Motion.Drag(obj, options);
                });
                return dg;
            }
        }
    } ();
    //#endregion 

    //#region Bx.Tags 标签操作类
    Bx.Tag = bxTag = function ()
    {
        /// <summary>标签操作类</summary>
        bxSys.extendDOMElement("css", function (cssName, value)
        {
            /// <summary>获取对象运行时的样式属性值,包括内联和外联CSS属性值</summary>
            /// <param name="obj">要获取属性值的对象</param>
            /// <param name="cssName">CSS属性名称，兼容Javascript属性名称</param>
            switch (cssName)
            {
                case ("scrollTop"):
                case ("scrollLeft"):
                    if (value == null) { return this[cssName]; } else { this[cssName] = bxParseInt(value, 0); }
                case ("opacity"):
                case ("alpha"):
                    if (bxNavigator.IsIE6 || bxNavigator.IsIE7 || bxNavigator.IsIE8)
                    {
                        var f = this.filters["DXImageTransform.Microsoft.Alpha"];
                        if (f == null)
                        {
                            if (this.filters.length > 0)
                            { this.style.filter += " progid:DXImageTransform.Microsoft.Alpha(enabled=true,opacity=100)"; } else { this.style.filter = "progid:DXImageTransform.Microsoft.Alpha(enabled=true,opacity=100)"; }
                        };
                        f = this.filters["DXImageTransform.Microsoft.Alpha"];
                        if (value == null) { return bxPub.parseInt(f.opacity, 0) / 100; }
                        else { f.opacity = value * 100; }
                    }
                    else
                    {
                        cssName = "opacity";
                        if (value == null) { return bxGetRuntimeStyle(this, cssName); }
                        else { eval("this.style." + cssName.replace(/(-\w)/g, function (a) { return (a.substring(1, 2).toUpperCase()); }) + "=value"); return this; }
                    }
                    break;
                default:
                    if (value == null) { return bxGetRuntimeStyle(this, cssName); }
                    else { eval("this.style." + cssName.replace(/(-\w)/g, function (a) { return (a.substring(1, 2).toUpperCase()); }) + "=value"); return this; }
            }

        });
        bxSys.extendDOMElement("getByClass", function (className, isFirstNode)
        {
            /// <summary>获取对象子结点中类名为指定名称的结点（集）</summary>
            /// <param name="className">css类名</param>
            /// <param name="isFirstNode">false:返回所有符合条件的结点数组;true:返回符合条件的第一个结点</param>
            var isFirstNode = isFirstNode == false ? false : true;
            var os = this.getElementsByTagName("*");
            var rs = [];
            for (var i = 0; i < os.length; i++)
            {
                if (bxStyle.CheckCssName(os[i], className))
                {
                    if (isFirstNode)
                    {
                        return $(os[i]);
                    }
                    else
                    {
                        rs.push($(os[i]));
                    }

                }
            }
            if (isFirstNode) { return null; }
            return rs;
        });
        bxSys.extendDOMElement("p", function (name, defaultValue)
        {
            /// <summary>查询对象的指定属性，兼容标签属性</summary>
            /// <param name="name">要查询的属性名称</param>
            /// <param name="defaultValue">当不具有该对象时返回值</param>       
            return (this != null && (name in this)) ? this[name] : ((this.attributes && (this.attributes[name] != null)) ? this.attributes[name].value : (arguments.length == 2 ? defaultValue : null));
        });
        return {
            tabRowAddCell: function (row, td)
            {
                /// <summary>向表格行追加一个单元格</summary>
                if (td) { row.appendChild(td); return td; }
                return row.insertCell(row.cells.length);
            },
            tabAddRow: function (tab)
            {
                return tab.insertRow(tab.rows.length);
            },
            removeTR: function (tr)
            {
                /// <summary>删除表格中的行</summary>

                $P(tr, "table").deleteRow(tr.rowIndex);
            },
            selGetValue: function (sel)
            {
                /// <summary>查询select的值</summary>
                if (sel.selectedIndex < 0) { return null; }
                return sel.options[sel.selectedIndex].value;
            },
            radioSetValue: function (name, v)
            {
                /// <summary>设置单选控件的值</summary>
                var rs = $N(name);
                for (var i = 0; i < rs.length; i++)
                {
                    var obj = rs[i];
                    if (obj.value == v) { obj.checked = true; }
                }
            }
        }
    } ()
    //#endregion 

    //#region Bx.Plugin插件操作类
    Bx.Plugin = bxPlugin = function ()
    {
        /// <summary>Plugins插件操作类</summary>
        return {
            getInfo: function (name)
            {
                /// <summary>获取插件信息</summary>
                /// <param name="name">插件名称</param>

                var name = name.toLowerCase();
                var ps = Bx.Environment.pluginList;
                for (var i = 0; i < ps.length; i++)
                {
                    if (name == ps[i].name)
                    {
                        return ps[i];
                    }
                }
                return null;
            },
            getURL: function (name)
            {
                /// <summary>获取插件路径</summary>
                /// <param name="name">插件名称</param>
                var f = this.getInfo(name);
                return f ? f.url : "";
            },
            run: function (name, fun, isAsync)
            {
                /// <summary>检测插件并执行执行函数，如果该插件还未加载，则先加载并运行插件</summary>
                /// <param name="name">插件名称</param>
                /// <param name="fun">执行函数</param>
                /// <param name="isAsync">是否是异步模板，默认为False，即同步模式</param>
                var pi = this.getInfo(name);
                var isAsync = isAsync != null ? isAsync : false;
                if (eval(pi.checkVar) != null)
                {
                    if (fun) { fun(); }
                    return true;
                }
                else
                {
                    bxSys.runJsFile(Bx.Environment.GetWebSiteUrl(pi.url), function ()
                    {
                        if (eval(pi.checkVar) != null)
                        {
                            if (fun) { fun(); }
                        }
                    }, isAsync);
                    return (eval(pi.checkVar) != null);
                }
            },
            Others: {},
            initTab: function (obj, options)
            {
                /// <summary>初始化指定选项卡控件</summary>
                this.run("tab", function ()
                {
                    if (obj)
                    {
                        bxTab.init(obj, options);
                    } else
                    {
                        bxTab.initDefault();
                    }
                });
            },
            getPageLoader: function ()
            {
                /// <summary>获取一个页面加载器实例</summary>
                var loader = {};
                bxPlugin.run("pageloader", function ()
                {
                    loader = new Bx.Plugin.Others.PageLoader();
                }, false);
                return loader;
            },
            initItemHelp: function ()
            {
                /// <summary>初始化提示控件</summary>
                if ($C("ItemHelp").length > 0)
                {
                    this.run("itemhelp", function ()
                    {
                        bxItemHelp.initDefault();
                    }, true);
                }
            }
        }
    } ();
    //#endregion 

    //#region Flash输出

    Bx.Pub.WriteFlash = bxWriteFlash = function (canvId, swfUrl, swfId, width, height, version, params, otherVariables)
    {
        /// <summary>向指定容器输出Swf动画</summary>
        /// <param name="canvId">窗口ID</param>
        /// <param name="swfUrl">swf文件URL</param>
        /// <param name="width">宽度</param>
        /// <param name="height">高度</param>
        /// <param name="version">版本</param>
        /// <param name="swfId">生成的对象ID</param>
        /// <param name="params">要添加的参数,json格式</param>
        /// <param name="otherVariables">其他传入变量数组json格式</param>
        bxPlugin.run("flash", function ()
        {
            var sf = new SWFObject(swfUrl, swfId, width, height, version);
            if (params)
            {
                for (var key in params)
                {
                    if (params.hasOwnProperty(key))
                    {
                        sf.addParam(key, params[key]);
                    }
                }
            }
            if (otherVariables)
            {
                for (var key in otherVariables)
                {
                    if (otherVariables.hasOwnProperty(key))
                    {
                        sf.addVariable(key, otherVariables[key]);
                    }
                }
            }
            sf.write(canvId);
        }, false);

    }
    //#endregion

    //#region 自动加载项
    if (bxNavigator.IsFireFox)
    {
        bxPlugin.run("fffix");
    }
    if (bxNavigator.IsIE6)
    {
        bxPlugin.run("ie6fix");
    }
    bxSys.addReady(function ()
    {

        bxBatch($T("img"), function (m, i)
        {
            if (m.title == "" && m.alt != "")
            {
                m.title = m.alt;
            }
        });
        if ($C("divTab").length > 0)
        {
            bxPlugin.run("tab", function ()
            {
                bxTab.initDefault();
            }, true);
        }


    });
    SysAddEvent(window, "onload", function ()
    {
        var vals = $A(document.body, "span", "isval");
        if (vals.length > 0)
        {
            bxValInit();
        }
        bxPlugin.initItemHelp();
    });
    //#endregion 


})();