CocoRoboDesktop/js/NetworkPromotion/NULL/NotUse1.js

/**
* 弹出1473窗体，需要删除。
* UDPD 父亲元素
*{object} UDE   放置窗体STYLE的地方    
* {int}UDE参数 [ "Embed": 是否是Iframe,
*          "Top": 偏移高,  "Left": 偏移左,  "Width": 长度,  "Height": 高度, 
*          "ContainerId": id,  "titleName": 标题,  "ContentId": 内容区Id, "Content": 内容, 
*          "hasScroll": 内容区是否滚动, "hasMax": 是否允许放大,  "hasMin": 是否允许缩小, 
*          "hasDraw": 是否拉伸, "CStyle": 内容区样式, "IsR":是否移除关闭按钮 
*               ]
* UCBF 单击确认的回调函数    UCNF 单击取消的回调函数
* @returns _UDOD    返回ID为U_COF的对象
**/
U.UF.UI.UForms = function (UDE, UDPD) {
    UDPD = UDPD || document.body; //选择是否有父亲元素，没有则BODY为父亲元素
    var i, _UIT, _UDOD, _UDTD, _UDSD, _UDCD, _UDED, _UAE, _UBE = [/%/, ["Width", "Height", "Top", "Left"]],
        _UCE = [ //绑定传入数据简写
            ["H", "up"],
            ["HL", "topRight"],
            ["HR", "topleft"],
            ["ML", "left"],
            ["MR", "right"],
            ["B", "down"],
            ["BL", "bottomLeft"],
            ["BR", "bottomRight"]
        ];
    for (i = 0; i < _UBE[1].length; i++) { //使用for循环绑定所传style
        _UBE[0].test(UDE[(_UIT = _UBE[1][i])]) && (UDE[_UIT] = US[{
            "Left": "Width",
            "Top": "Height"
        }[_UIT]] * UDE[_UIT].toInt() / 100)
    }
    _UDOD = $$("div", { //创建窗体
        "className": "UD_W UD_UIU",
        "id": UDE.ContainerId,
        "style": {
            "width": UDE.Width + "px",
            "height": UDE.Height + "px",
            "left": UDE.Left + "px",
            "top": UDE.Top + "px"
        }
    });
    $$("div", { "className": "UD_ICON UD_ICONl"}, _UDOD);//创建窗体的头
    _UDTD = $$("div", { //创建窗体的子集
        "className": "UD_WIMG UD_W_TB",
        "style": {
            "width": (UDE.Width - 30) + "px"
        },
        "onmousedown": [
            [U.UF.F.DragMouseDown, [_UDOD]]
        ]
    }, _UDOD);
    $$("span", {"className": "UD_W_TB_T","innerHTML": UDE.titleName}, _UDTD); //span存放文字地方
    _UDSD = $$("div", {"className": "UD_W_TB_WM"}, _UDTD); //创建存放对象
    $$("span", { //关闭窗口元素
        "title": "关闭",
        "className": "UD_ICON UD_W_TB_WM_Close",
        "onmousedown": U.UF.EV.stopBubble,
        "onclick": [
            [U.UF.F.closeWindow, [_UDOD, (UDE.IsR ? "remove" : "")]]
        ]
    }, _UDSD)
    $$("div", {"className": "UD_ICON UD_ICONR"}, _UDOD); //创建对象
    _UDCD = $$("div", { //创建格式对象
        "className": "UD_WIMG UD_ICONz",
        "style": {
            "height": UDE.Height - 36 + "px"
        },
        "onmousedown": U.UF.EV.stopBubble
    }, _UDOD);
    _UDED = $$("div", { //创建格式对象
        "id": UDE.ContainerId + "Content",
        "className": "UD_W_WC",
        "style": {
            "cssText": "height:100%;" + UDE.CStyle
        }
    }, _UDCD);
    if (UDE.Embed == 0) { //添加内容区域
        $$("iframe", {//设定内容初始值
            "id": UDE.ContentId,
            "name": UDE.ContentId,
            "frameBorder": 0,
            "scrolling": UDE.hasScroll,
            "src": UDE.Content,
            "width": "100%",
            "height": "100%"
        }, _UDED);
    } else {
        U.selectEl(_UDED).append(UDE.Content);
    }
    //事件区域
    _UAE = {
        "with": [{  //事件区域高度
            "Element": _UDCD,
            "height": -36
        }, {    //事件区域宽度
            "Element": _UDTD,
            "height": 0,
            "width": -30
        }]
    }
    if (UDE.hasDraw) {
        for (i = 0; i < _UCE.length; i++) {
            $$("span", {
                "className": "UD_W_WT_" + _UCE[i][0],
                "onmousedown": [
                    [U.UF.F.RCDG, [_UDOD, _UCE[i][1], _UAE]]
                ]//鼠标按中时发生事件,改变窗体。
            }, _UDOD);
        }
    } //允许拉伸
    (UDE.hasMax) && ($$("span", { //最大化拉伸
        "title": "最大化",
        "className": "UD_ICON UD_W_TB_WM_Max",
        "onmousedown": U.UF.EV.stopBubble,
        "onclick": [
            [U.UF.F.windowZooming, [_UDOD, this, _UAE, _UDTD, {
                "onmousedown": _UDTD.onmousedown
            }]]
        ]
    }, _UDSD));
    (UDE.hasMin) && ($$("span", { //最小化拉伸
        "title": "最小化",
        "className": "UD_ICON UD_W_TB_WM_Min",
        "onmousedown": U.UF.EV.stopBubble,
        "onclick": [
            [U.UF.F.windowMinimize, [_UDOD]]
        ]
    }, _UDSD));
    _UDTD.onmousedown = (UDE.Width == US.width && UDE.Height == US.height) ? U.UF.C.apply(this[[U.UF.F.DragElement, [_UDOD, null, _UAE, _UDTD, {
        "onmousedown": _UDTD.onmousedown
    }])]] : _UDTD.onmousedown;
    (UDPD) && (UDPD.appendChild(_UDOD));
    U.UF.SI[UDE.Left || UDE.Top ? "SetDTop" : "PopupWindow"](_UDOD);
    return _UDOD; //添加
}

/**
* 创建1473窗体
* UDPD 父亲元素    
* {int} UDOD主体元素, UTE标题, UDID id, UST表示内容 ,UCS css样式 UW, UH长。
**/
U.UF.UI.SUForms = function (UDOD, UTE, UDID, UST, UCS, UW, UH) {
    var _UDW = US.width,
        _UDH = US.height;
    return U.UF.UI.UForms({    //返回属性
        "Embed": 1,
        "Top": (_UDH - UH - 50) / 2,
        "Left": (_UDW - UW) / 2,
        "Width": UW,
        "Height": UH,
        "ContainerId": UDID,
        "titleName": UTE,
        "ContentId": "",
        "Content": UST,
        "hasScroll": "no",
        "hasMax": false,
        "hasMin": false,
        "hasDraw": false,
        "CStyle": UCS,
        "IsR": true
    }, UDOD);
}

//    getStartE: function () {
//        if (window.getSelection) { //Html5
//            return this.R.startContainer;
//        } 
//        else { 
//            var _UDOD = this.Parent();
//        }
//    },

//    getEndE: function () {
//        if (window.getSelection) {
//            return this.R.endContainer;
//        } //Html5
//        else {
//            var _UDOD = this.Parent();
//        }
//    },

//    selectAll: function () { },


//富文本编辑器
U.UF.E.RuchEditor = function (UDE) {
    U.UF.UI.Editor((U.UF.C.isFunction(UDE) || !UDE) ? { head: true, style: { width: "600px", height: "500px" }, title: false, name: "在线编辑", fcb: UDE} : UDE);
}


//上传文件成功显示到制定的区域
U.UF.E.AddUPWJ = function (UTE, UDBD) {
    var _UDOD, _UDTD, _UDSD, _UIID = Guid.newGuid().replace(/-/g, ""),
    _UME = U.UF.UP.XWPGYS(UTE["type"]);
    if (_UME[2]) { //普通文件上传显示
        _UDOD = $$("div", { "contentEditable": "false", "className": "UD_UPO", "onclick": [[]] });
        _UDTD = $$("div", { "contentEditable": "false", "className": "UD_UPOL" }, _UDOD);
        $$("div", { "contentEditable": "false", "className": "UD_SYVCOI UD_SYID " + _UME[0] }, _UDTD);
        _UDSD = $$("div", { "contentEditable": "false", "className": "UD_UPOR" }, _UDTD);
        $$("div", { "contentEditable": "false", "innerHTML": UTE["name"], "className": "UD_UPORN" }, _UDSD);
        $$("div", { "contentEditable": "false", "innerHTML": "下载", "className": "UD_UPORX" }, _UDSD);
        $$("div", { "contentEditable": "false", "innerHTML": "保存到网盘", "className": "UD_UPORB" }, _UDSD);
        if (UIMG) { _UDTD = UDBD.parentNode; _UDTD.replaceChild(_UDOD, UDBD); }
    }
    else { //图片区域
        if (UDBD) {
            U.UF.IMG.imgReady(U.MD.C.getHeadImage(US.FILESYSTEMURL + UTE["URL"]), null, function(){U.UF.E.ImgOnLoad(UDBD]]]), U.UF.C.apply(null, [[U.UF.E.ImgOnLoad, [);});
        } //加载原图
        else {
            var _UIID = Guid.newGuid().replace(/-/g, ""); _UDOD = $$("img", { "id": _UIID, "src": "/img/imgloading.gif", "onmousedown": "return false", "onselectstart": "return false", "ondragstart": "return false", "style": { "cssText": "max-width:100%;width:auto;height:auto;"} });
        } //正在上传等待
    }
}

//上传图片预加载成功或者失败
U.UF.E.ImgOnLoad = function (UIID) {
    if (UIID) {
        U.selectEl(UIID).addAttrArray({ "onload": "if (U.MD.F) { U.MD.F.H.SUIMG(retElement); }", "src": this.src, "width": this.width, "height": this.height });
    }
    else {
        U.MD.C.imgError(this, 2);
    }
}


/**
* 创建群组
*
* @param  {object} 群信息
*/
U.MD.F.J.APPGroup = function (UDE) {
    //  U.MD.F.J.GroupInfoForm(UDE, null);
    //    var _UTE,
    //    _UDFD = $$("div", {}, U.selectEl("#UD_SY")[0]),
    //    _UDMD = U.MD.F.J.GroupInfoForm(UDE, null, _UDFD), //插入添加创建群信息
    //    _UDTD = U.MD.F.J.SelectFriendForm($("#UD_SYTC")[0], null, _UDFD); //插入添加好友的信息

    //    //设置样式处理
    //    $[_UDMD.form, _UDTD.form].addAttrArray({ onmousedown: null, "className": "UD_SYF_S", "style": { "border": "0", "position": "relative", "float": "left", "top": "0", "left": "0"} });
    //    _UDMD.head.onmousedown = _UDTD.head.onmousedown = null;
    //    _UDMD.form.style.borderRight = "1px solid #444";

    //    //弹出添加群的框
    //    _UTE = new U.UF.UI.form({ id: "U_F_CONET", isContain: false, content: _UDFD, bst: { "style": { "overflow": "hidden"} },
    //        "style": { "width": "736px", "height": "485px", "backgroundColor": "transparent", "overflow": "hidden" },
    //        title: false, draw: false, max: false, close: false, min: false
    //    });

    //    _UDMD.cl.onclick = _UDTD.cl.onclick = U.UF.C.apply(_UTE, [[_UTE.shut]]);  //关闭按钮处理
}


/**
* word编辑处理  不使用
*
*/
U.MD.O.Del = function (UTE) {
    //    var i, j, k, _UTF, _UDMD, _UKE = [], _UVE = [], _UCE = ["nodeValue", "innerHTML"], _UAE = ["width", "height", "minHeight", "minWidth"], _UDOD = $$("div", { "innerHTML": UTE.GetSelectedHtml() }), _UDCD = U.selectEl(_UDOD).Nodes(), _UIE = UTE.GetGBWZ(), _UDPD = UTE.Parent(), _UDAD = U.selectEl(_UDPD).Nodes(), _UTH = (_UDPD.nodeValue == null ? _UDPD.innerText : _UDPD.nodeValue).replace(/\s|\n/g, "");
    //    if ($(_UDOD).Child().length) {
    //        if (_UDPD.nodeType != 3 && UTE.isE(_UDPD)) { _UVE.push(_UDPD); } for (i = 0; i < _UDAD.length; i++) { if (_UDAD[i].nodeType != 3 && UTE.isE(_UDAD[i])) { _UVE.push(_UDAD[i]); }; }
    //        for (k = 0; k < Math.min(_UVE.length, 2); k++) {
    //            _UDMD = _UVE; j = k ? _UDMD.length - 1 : 0;
    //            do { if (UTE.isE(_UDMD[j])) { _UDCD = _UDMD[j]; _UDMD = U.selectEl(_UDCD).Nodes(); j = j = k ? _UDMD.length : -1; } } while ((k ? ((j -= 1) > -1) : ((j += 1) < _UDMD.length)));
    //            if (_UDCD) { for (i = 0; i < _UCE.length; i++) { if (_UDCD[_UCE[i]] != null) { _UDCD[_UCE[i]] = _UDCD[_UCE[i]].substring.apply(_UDCD[_UCE[i]], k ? [(UTE.GetGBWZ(_UDCD, !k))] : [0, (UTE.GetGBWZ(_UDCD, !k))]); break; } } _UKE.push(_UDCD); }
    //        }
    //        for (i = 0; i < _UVE.length; i++) {
    //            _UDCD = U.selectEl("*", _UVE[i]);
    //            if (_UDCD.length) {
    //                for (j = 0; j < _UDCD.length; j++) {
    //                    //   for (k = 0; k < _UAE.length; k++) { if ((_UTF = _UDCD[j].style[_UAE[k]]) && _UTF != "auto") { break; } }
    //                    if ((k != _UAE.length || (_UDCD[j].className || _UDCD[j].id))) {
    //                        if (!$(_UDCD[j]).Child().length) {
    //                            for (k = 0; k < _UCE.length; k++) {
    //                                if (_UDCD[j][_UCE[k]] != null && (!_UKE[0] || !U.UF.EL.isChild(_UDCD[j], _UKE[0])) && (!_UKE[1] || !U.UF.EL.isChild(_UDCD[j], _UKE[1]))) { _UDCD[j][_UCE[k]] = ""; break; }
    //                            }
    //                        }
    //                    }
    //                    else if (_UDCD[j] != _UKE[0] && _UDCD[j] != _UKE[1] && !_UDCD[j].innerHTML) { U.selectEl(_UDCD[j]).remove(); }
    //                }
    //            }
    //            else { for (i = 0; i < _UKE.length; i++) { if (!U.UF.EL.isChild(_UVE[i], _UKE[i])) { if (_UVE[i].className || _UVE[i].id) { U.selectEl(_UVE[i]).remove(); } else { _UVE[i].innerTEXT = ""; } break; } } }
    //        }
    //        UTE.R.collapse(false); return _UKE;
    //    }
}

U.MD.O.OLWordUP = function (UTF, UDE, UTE, UT, UWE) {
    //    var i, _USE, _UCE = ["nodeValue", "innerHTML"], _UIE = UTE.GetGBWZ(), _UDPD = UTE.Parent(), _UTH = (_UDPD.nodeValue == null ? _UDPD.innerText : _UDPD.nodeValue).replace(/\s|\n/g, "");
    //    if (!U.UF.C.isString(UTF) && (!UT[1] && !UT[2] && !UT[3])) {
    //        if (((UT[0] > 47 && UT[0] < 112) || (UT[0] > 185 && UT[0] < 193) || (UT[0] > 218 && UT[0] < 223))) {
    //            if ((_USE = U.MD.O.Del(UTE)) && _USE[0]) { UTE.QX(-1, -1, _USE[0]); }
    //        }
    //    }
    //    else {
    //        switch (UTF) {
    //            case "del": case "Backspace":
    //                if ((_USE = U.MD.O.Del(UTE)) && _USE[0]) { return 1; }
    //                else if (_UDPD.className) { if ((!_UIE && UTF == "Backspace") || (_UIE == _UTH.length && UTF == "del")) { return 1; } else if (_UTH.length == 1 && _UTH != "") { _UDPD.innerText = ""; return 1; } else if (!_UTH.length) { return 1; } }
    //                break;
    //            case "Enter":
    //                if (_UDPD.nodeType != 3) {
    //                    if (("DIV,SPAN,P".indexOf(_UDPD.tagName) == -1 && _UDPD.className.indexOf("return_key") > -1)) { return 1; }
    //                    else if (_UDPD.style.cssText) { UTE.Replace("<div>&#8203</div>"); return 1; }
    //                }
    //                break;
    //            case "save":
    //                (UWE.U.MD.O.W || UWE.U.MD.O.E).Save(); return 1;
    //                break;
    //        }
    //    }
}



//#region 初始化首页

///**
//* 初始化首页
//*
//* @param  {object} 任务栏数据
//*/
//U.MD.D.H.SYTJ = function (UDE) {
//    if (UDE) {  //打印推荐用户
//        U.MD.D.H.PSYTJN($("#UD_SYSXSSXOC")[0], UDE);
//    }
//    else {
//        U.A.Request(US.CD, [US.DB, "UseStudio_Friends", "RecommendFriends", US.userInfo.userid || US.EMPTYGUID, 0, 11]), U.MD.D.H.AsynSYTJ, [""];
//    }
//}

///**
//* 首页推荐数据异步推荐
//*
//* @param  {object} 任务栏数据
//*/
//U.MD.D.H.AsynSYTJ = function (r) {
//    U.MD.D.H.ET["TJ"] = r = r.value;
//    U.MD.D.H.SYTJ(r);
//}

///**
//* 打印首页推荐好友New
//*
//* @param  {object} 任务栏数据
//*/
//U.MD.D.H.PSYTJN = function (UDOD, UDE, UTF, UP) {
//    var i, _UDSD = $$("frag"); UDOD.innerText = "";
//    for (i = 0; i < UDE.length; i++) {
//        $$("img", { "onerror": U.MD.C.imgError, "title": UDE[i].UserName, "alt": UDE[i].UserName, "onclick": function(){U.MD.U.V.ViewOtherUserInfo(UDE[i].UserID);}, "src": U.MD.C.getHeadImage(UDE[i].UserThumbnailImageHead) }, _UDSD);
//    }
//    (UTF) && ($$("div", { "className": "UD_SYSXLTTI UD_SYSXLTTIO U_Boom_Img_ys2017", "title": "点击刷新", "onclick": function(){U.MD.D.H.SXZX(UP || 2, this, 28, function(){U.MD.D.H.PSYTJNSX(UTF);});} }, _UDSD)); UDOD.appendChild(_UDSD);
//}

//#endregion




/*
Form窗体的使用 
1、可以像java语言的用法，用new调用多份，例如： var a=new new U.UF.UI.form();
2、也可以省略new的步骤，直接U.Alert()，出来的结果为多份。
3、多窗口模式调用方法，var e= U.UF.UI.form (UDE); e.addExtendForm();
参数一：_UFE[add "name":"add"]
参数二：_UTT 存放大小变化的值
返回值：
*/

/**
* 可以像java语言的用法，用new调用多份，例如： var a=new new U.UF.UI.form();
*
* @param  {object} 窗体使用传参
----------min 是否允许最小化
----------max 是否允许最大化
----------id 窗体id
----------style 窗体的样式
----------content 窗体的内容
----------title 窗体的标题
----------hst 标题设置
----------cst 内容设置
---------__top__  是否允许点击置顶
* @return  {object} 窗体实体
*/
   U.UF.UI.form = U.UF.UI.form = function (UDE) {
    return new new U.UF.UI.form.init(UDE).create();
}


/**
* 可以像java语言的用法，用new调用多份，例如： var a=new new U.UF.UI.form();
*
* @param  {object} 窗体使用传参
----------min 是否允许最小化
----------max 是否允许最大化
----------id 窗体id
----------style 窗体的样式
----------content 窗体的内容
----------title 窗体的标题
----------hst 标题设置
----------bst 内容设置
----------draw 是否允许拉伸
* @return  {object} 窗体本身
*/
new U.UF.UI.form.init = function (UDE) { //初始化
    U.UF.C.AddObj(this, UDE);
    return this;
}

new U.UF.UI.form.et = {}; //所有窗体集合

//窗体使用函数
new U.UF.UI.form.init.prototype = {
    et: new U.UF.UI.form.et, //所有窗体集合 
    //构建元素
    create: function () {
        var i, _USE, _UDOD, _UDTD, _UDSD, _UAE, _UTE = this,
                _UTI = this.title, //标题元素
                _UCT = this.content, //内容元素
                _UCE = [
                    ["H", "up"],
                    ["HL", "topRight"],
                    ["HR", "topleft"],
                    ["ML", "left"],
                    ["MR", "right"],
                    ["B", "down"],
                    ["BL", "bottomLeft"],
                    ["BR", "bottomRight"]
                ];
        if (this.id && this.et[this.id] && this.et[this.id].form.id == this.id) { //无需创建
            _UTE = this.et[this.id]; //获取当前窗体属性
            _UTE.form.style.cssText = "";
            (_UTE.body) && (_UTE.body.style.cssText = "");
            U.selectEl(_UTE.form).addAttrArray({
                className: this.className ? this.className : "UD_SYF_S UD_SYKO", //css样式名"UD_SYF_S UD_SYKO"
                close: U.UF.C.apply(_UTE, _UTE.shut),
                "__top__": this.top ? "false" : "", //是否允许点击置顶
                "__right__": this.right || "",
                usform: "true", //设置窗体属性
                "id": this.id || "", //绑定继承ID
                "style": this.style || {}
            });
            ($(_UTE.body).addAttrArray(this.bst));
            (_UTI && (_UTE.title = _UTI)) && (U.UF.C.isString(_UTI) ? (_UTE.head.innerHTML = _UTI) : (_UTE.head.innerHTML = "", U.selectEl(_UTE.head).append(_UTI))); //重新设置标题
            (_UCT && (_UTE.content = _UCT)) && (U.UF.C.isString(_UCT) ? ((U.UF.C.isUrl(_UCT)) ? "" : _UTE.body.innerHTML = _UCT) : (($(_UCT).Parent() != _UTE.body) && (_UTE.body.innerText = "", U.selectEl(_UTE.body).append(_UCT)))); //内容设置
            _UDOD = _UTE.form;
        }
        else { //创建窗体
            (this.form = _UDOD = $$("div", {  //创建元素
                className: this.className ? this.className : "UD_SYF_S UD_SYKO", //css样式名"UD_SYF_S UD_SYKO"
                close: function(){this.shut();},
                "__top__": this.top ? "false" : "", //是否允许点击置顶
                "__right__": this.right || "",
                usform: "true", //设置窗体属性
                "id": this.id || "", //绑定继承ID
                "style": this.style || {}
            })).onresize = U.UF.C.apply(this, [[this.size]]); //设置元素变化事件
            (this.attr) && ($(this.form).addAttrArray(this.attr));
            if (this.title !== false) {
                this.head = _UDTD = $$("div", {
                    className: "UD_SYF_ST",
                    onmousedown: function(){U.UF.F.DragMouseDown(_UDOD, null, this);}  //窗体拖动//鼠标事件按下发生
                }, _UDOD);
                //重载hst为headerStyle,更加语义化.
                (this.headerStyle) && ($(_UDTD).addAttrArray(this.headerStyle));
                (this.hst) && ($(_UDTD).addAttrArray(this.hst)); //给标题头部添加样式
                (_UTI != null) && ($(_UDTD).append(_UTI)); //添加头部
            } else if (this.draw !== false) {
                _UDOD.onmousedown = function(){U.UF.F.DragMouseDown(_UDOD);}; //窗体拖动
            }
            if (this.content !== false) {//判断元素是否有bst，添加
                _UDTD = $$("div", {
                    className: "UD_SYF_SC"
                }, _UDOD);
                this.body = _UDTD = $$("div", {
                    usbody: "true",
                    className: "UD_SYF_SCO"
                }, _UDTD);
                (this.bst) && ($(this.body).addAttrArray(this.bst));
                U.selectEl(_UDTD).bind("scroll", function(){this.scroll();}); //避免闭包耗费资源。
                //iframe的处理方式
                if (_UCT != null) {
                    if (U.UF.C.isUrl(_UCT)) {
                        $$("iframe", {
                            scrolling: this.Scroll || "no",
                            frameBorder: 0,
                            width: "100%",
                            height: "100%",
                            src: _UCT
                        }, _UDTD);
                    } else if (_UCT) {
                        (this.bst) && ($(_UDTD).addAttrArray(this.bst));
                        if (U.UF.C.isString()) {//添加内容
                            _UDTD.innerHTML = _UCT;
                        }
                        else {
                            U.selectEl(_UDTD).append(_UCT); //添加所选元素
                        }
                    }
                }
            }
            this.zie = _UAE = {//添加属性size
                fun: function(){this.size();}
            };
            _UDTD = $$("div", {//创建_UDTD添加到_UDOD
                className: "UD_W_WT"//添加CLASS属性
            }, _UDOD);
            if (this.draw !== false) {
                for (i = 0; i < _UCE.length; i++) {
                    $$("div", {
                        className: "UD_W_WT_" + _UCE[i][0],
                        onmousedown: [//鼠标事件
                                [U.UF.F.RCDG, [_UDOD, _UCE[i][1], _UAE]]
                            ]
                    }, _UDTD);
                }
            } //允许拉伸
            U.selectEl(this.SO ? (this.SO[0] || this.SO) : ($("#UD_SY")[0] || document.body)).append(this.form, 0, this.SO ? this.SO[1] : null);
            _USE = this.head ? U.UF.EL.getElementInfo(this.head) : null;
            _UDSD = $$("div", {
                className: "UD_SYF_SCA",
                style: {
                    "lineHight": _USE ? _USE.CH + "px" : "",
                    "top": _USE ? Math.ceil((_USE.OH - 20) / 2) + "px" : "15px" //定义高度属性为(_USE.OH - 20) / 2
                }
            }, _UDOD); //添加至_UDOD
            //功能将处理
            (this.htask) && ($(_UDSD).addAttrArray(this.htask));
            (this.close !== false) && (this.close = this.close || {}, this.cl = $$("div", {
                className: "UD_SYF_SS U_Boom_Img_ys2017",
                title: "点击关闭",
                onmousedown: U.UF.EV.stopBubble,
                onclick: function(){this.shut();}
            }, _UDSD));
            _USE = this.et[this.id] = this;
            //最大化最小化的按钮
            (this.max !== false) && (this.max = this.max || {}, this.m = _UDTD = $$("div", {
                className: "UD_SYF_SD U_Boom_Img_ys2017",
                title: "最大化",
                onmousedown: U.UF.EV.stopBubble
            }, _UDSD), _UDTD.onclick = U.UF.C.apply(null, [
                    [U.UF.F.windowZooming, ([_UDOD, _UDTD, {
                        fun: U.UF.C.apply(this, [
                            [this.size]
                        ])
                    }, this.head || _UDOD, {
                        "onmousedown": (this.head || _UDOD).onmousedown
                    }])]
                ]), (this.head) && (this.head.ondblclick = U.UF.C.apply(this.head, function () {
                    (event.srcElement == this || U.UF.EL.isChild(this, event.srcElement)) && (_UDTD.onclick());
                }))); //
            (this.min !== false) && (this.min = this.min || {}, this.mi = $$("div", {
                className: "UD_SYF_SF U_Boom_Img_ys2017",
                title: "最小化",
                onmousedown: U.UF.EV.stopBubble,
                onclick: [
                        [U.UF.F.windowMinimize, [_UDOD]]
                    ]
            }, _UDSD));
        }
        //不允许拖动设置
        (_UTE.isContain) && (((_UTE.head) && (_UTE.head.onmousedown = null)) || (_UDOD.onmousedown = null)); //$(_UDOD).css({ position: "static" }),
        _UAE = _UTE.style ? [_UTE.style.top, _UTE.style.left] : [];
        //弹出窗体
        (!this.style || this.style.display != "none") && (U.UF.SI[_UAE[0] && (_UAE[0].indexOf("px") > -1 || _UAE[0].indexOf("%") > -1) || _UAE[1] && (_UAE[1].indexOf("px") > -1 || _UAE[1].indexOf("%") > -1) ? "SetDTop" : "PopupWindow"](_UDOD, true));
        _UTE.form = _UDOD;
        //设置置顶
        (_UTE.top) && ($(_UTE.form).css("zIndex", 9999));
        _UTE.size(true);
        return _UTE;
    },
    //关闭窗体
    shut: function () {
        if (!this.close || !this.close.onclick || this.close.onclick(this.form) !== false) {
            U.UF.F.closeWindow(this.form, this.del ? this.del : null); //关闭窗体
        }
    },
    /**
    * 变大缩小适应
    *
    * @param  {object} 窗体使用传参
    */
    size: function (UTF) {
        if (this.draw !== false && this.max !== false || this.title !== false) {
            if (!(this.bst && this.bst.height) && this.form.style.height != "auto") {  //判断是否为自适应
                var _UH,
            _USE = [this.head ? U.UF.EL.getElementInfo(this.head) : [], U.UF.EL.getElementInfo(this.body)] //获取padding大小
                //|| (US.height * 0.7); //等比例百分比
                if (_UH = U.selectEl(this.form).height()) { U.selectEl(this.body).css("height", _UH - (_USE[0]["OH"] || 0) - (_USE[1]["PD"][0] || 0) - (_USE[1]["PD"][2] || 0) + "px"); } //大小设置
            }
            if (UTF !== true) { //利用回调函数调用
                (!this.TI && this.resize) && (this.resize.call(this, this.form, this.head, this.body)); //回调窗体变化
                clearTimeout(this.TI);
                this.IsSize = true;
                this.TI = setTimeout(function(){this.sizeend();}, 0); //窗体结束调用
            }
        }
    },
    //大小变化结束出发
    sizeend: function () {
        this.TI = null;
        (this.resizeend) && (this.resizeend(this.form));
    },
    //窗体变化
    allSize: function () {
        var i, _UDE = this.et;
        for (i in _UDE) {
            if (_UDE[i].IsSize) {
                _UDE[i].IsSize = false;
            } else {
                _UDE[i].size();
            }
        }
    },
    //滚动使用
    scroll: function () {
        if (this.s || this.ss || this.se) {
            (this.s) && (this.s());
            (!this.iss) && (this.scrollStart());
            this.iss = true; //滚动开始触发
            clearTimeout(this.TI);
            this.TI = setTimeout(function(){this.scrollEnd();}, 0); //触发加载
        }
    },
    //滚动开始
    scrollStart: function () {
        (this.ss) && (this.ss()); //滚动开始回调
    },
    //滚动结束
    scrollEnd: function () {
        (this.se) && (this.se()); //滚动结束回调
        this.iss = false;
    },
    //滚动到底部触发
    scrollBottom: function () {
    },
    //添加属性
    add: function (UDE) {
        U.UF.C.AddObj(this, UDE);
    }
}


/**
* onload成功进入
* @param  {element} 加载的元素
* @param  {function} 回调函数
*/
//U.UF.DL.iframeLoad.AILD = function (UDOD, cb) {
//    var _URS = UDOD.readyState;
//    (_URS == "complete" || _URS == "loaded" || _URS == null) && (UDOD.complete = "complete", UDOD.onreadystatechange = null, (U.UF.C.isFunction(cb) ? cb.call(UDOD) : function(){cb();}()), UDOD.complete = null);
//}

////判断文件是否存在
//U.UF.DL.ISWJCZ = function () {
//    $.ajax(UURL, "", cb, "", { "type": "get" });
//}

/**
设置元素loading
问题：
----添加一个参数，允许往loading中传递元素。
----在第一个loading数据量大未出数据的时候，点第二个loading，第二个先获取到数据，会否第二个会先出效果。
----由于第一次点击数据量大，后台是否能够第二个数据先出。
----由于第一次点击数据量大，前台loading的效果是否支持第二以及后续点击先出。
*
* @param  {element} 元素
* @param  {boolean} loading类型
------------true 、 false 两种loading   
*/
/*U.UF.DL.loading = function (UDOD, UTF) {
    if (UDOD) {
        var i, _UAE, _UDTD, _UDPD = U.selectEl(UDOD).Parent(),
        _UDSD = UDOD ? UDOD.__ULOADElement__ : null, //该元素的loading元素
        _USE = { width: "", height: "", overflow: "", padding: "", borderWidth: "", minHeight: "", minWidth: "", cssText: "" }; //loading设置样式区域
        if (_UDSD) {//loading存在添加计数
            if (UDOD != _UDSD) { _UDSD.P++; }
        }
        else {  //无loading 需要loading的情况
            _UDSD = UDOD.__ULOADElement__ = $$("div", { "P": 0, "className": UDOD.className, //这个为loading元素
                "style": { "cssText": UDOD.style.cssText + ";" + ($(UDOD).css("display") == "none" ? "display:block" : "") },
                "onresize": function(){U.UF.DL.loading.Donresize(this);}
            });
            if (UTF === true) {//loading样式1
                $$("div", { "style": { "cssText": "overflow:hidden;width:40px;height:20px;background:url('/img/Loading.gif') 0px 0px no-repeat;margin:auto"} }, _UDSD);
            }
            else { //loading样式2
                $$("div", { "style": { "cssText": "position:relative;width:" + (UTF && UTF.width ? UTF.width : "33px") + ";height:" + (UTF && UTF.height ? UTF.height : "33px") + ";background:url('" + (UTF && UTF.img ? UTF.img : "/img/UAL.gif") + "') 0px 0px no-repeat;margin:auto"} }, _UDSD);
            }
            try { _UDPD.insertBefore(_UDSD, UDOD); } //loading 添加到指定的位置
            catch (e) { }
            //loading样式设置
            U.UF.DL.loading.Donresize(_UDSD, UDOD, UTF);
            _UAE = UDOD.style;
            U.Json.Each(_USE,function (USV, UTP) { _USE[UTP] = _UAE[UTP]; });
            //原元素缩小
            (UDOD = U.selectEl(UDOD)).addAttrArray({ "__UCS__": _USE, "style": { "cssText": "width:0px;overflow:hidden;height:0px;padding:0;min-height:0px;min-width:0px;border-width:0px;"} });
        }
        return _UDSD;
    }
}*/


/**
* css动画
*
* @return  {array} 过渡属性的值
-----------[0] 动画的css 
-----------[1] 动画的回调函数 
-----------[2] 兼容的前缀 
-----------[3] 浏览器过渡的监视属性 
-----------[4] 浏览器结束的属性 
*/
U.UF.C.CssAm = function () {
    var i, //遍历初始化
    _USE = $$("div").style; //获取div的样式
    //_UDE css动画属性名数组
    var _UDE = {
        "animation": ["animation", "animationEnd", "", "webkitRequest", "webkitCancel"],
        "OTransition": ["-o-transition", "oTransitionEnd", "-o-", "oRequest", "oCancel"],
        "MozTransition": ["-moz-transition", "transitionend", "-moz-", "mozRequest", "mozCancel"],
        "MsTransform": ["-ms-transition", "transitionend", "-ms-"],
        "transition": ["transition", "transitionend", "", "r", "cancel"]
    }
    for (i in _UDE) { //循环判断兼容
        if (_UDE.hasOwnProperty(i) && _USE[i] !== undefined) {
            _UDE[i].push(i);
            return _UDE[i];
        }
    }
}

,

    Auxiliary: {
        an: function (UDE) { //缓存对象设置

        },
        slideToggle: function (UDE, UIE, UL, cb) { //下拉动画回调
            this[UIE].style.cssText = UDE; (UIE == UL - 1 && cb) && (cb());
        },
        animate: function (UDE, UAE, UIE) {//js动画调用使用区域
            var _UTF, _USE, i = UDE[0] || 0,
            _UL = UDE[1] || i + 1,
            _UTID = UDE[2],
            _UCB = UDE[3];
            for (; i < _UL; i++) {
                if (UIE) { _USE = U.UF.C.JsEM(this[i], UAE, UIE); }
                else { _USE = UAE; _UTF = true; } this.addAttrArray(_USE, i);
            }
            if (_UTF) {
                (_UTID == null && _UCB) && (_UCB()); return true;
            }
        },
        selectel: function (UTF, UDE) { //条件选择元素
            var _UFT, i = 0, _UL = UDE.length, _UCE = [], _UAE = U.select(), _UIE = UTF.match(U.UF.S.RNum);
            if (_UIE) { _UIE = _UIE[0].toInt(); switch (UTF.replace(_UIE + "", "")) { case ">": i = _UIE + 1; break; case "<": _UL = _UIE; break; default: i = _UIE; _UL = i + 1; break; } }
            for (; i < _UL; i++) { switch (UTF) { case "even": _UFT = !(i % 2); break; case "odd": _UFT = (i % 2) > 0; break; default: _UFT = true; break; } (_UFT) && (_UCE.push(UDE[i])); _UFT = false; }
            return _UAE.osadd(_UCE);
        }
    }

/**
* css动画异步
*
* @return  {array} 过渡属性的值
*/
U.UF.C.JsEM = function (UDOD, UDE, UHK, UTF) {
    var i, //遍历初始化
    j, //循环初始化
    _UCE, //储存字符串
    _USE = [], //初始化数组
    _UME = {}, //初始化对象
    _UM = /[^\d-|.]+/ig, //正则表达式
    _UNUM = /[\d-|.]+/ig; //正则表达式
    for (i in UDE) {
        if (UDE.hasOwnProperty(i)) {
            if (i == "style") {//style的制作
                _UCE = U.UF.C.jsonToStr(U.UF.C.JsEM(UDOD[i], UDE[i], UHK, true));
                (_UCE.length > 2) && (_UME[i] = { "cssText": _UCE.replace(/["|{|}]+/ig, "").replace(/,/ig, ";") });
            }
            else {//普通动画
                _USE[0] = UDOD[i] || 0; _USE[1] = UDE[i]; for (j = 0; j < _USE.length; j++) {
                    (typeof _USE[j] != "number") && (_USE[j] = Number(_USE[j].replace(_UM, "")));
                } //生成位置
                if (!isNaN(_USE[0])) { //动画获取
                    j = UTF ? U.UF.EL.styleConversion(i, true) : i;
                    _UME[j] = _USE[0] + ((_USE[1] - _USE[0]) * UHK); _USE[1] = UDOD[i] ? UDOD : UDE;
                    (typeof _USE[1][i] == "string") && (_UME[j] = _USE[1][i].replace(_UNUM, _UME[j]));
                }
            }
        }
    }
    return _UME;
}


/**
* 动画初始化
*
* @param  {object} 动画设置对象 
*/
U.UF.C.Animation = function (UDE) { //基础对象
    return new U.UF.C.Animation.init(UDE, U.UF.C.Animation.get());
}

U.UF.C.Animation.get = function () {
    var i, j, //循环变量
    _UFE,
    _UDE = [["r", "cancel"], ["", "moz", "webkit", "o"]]; //兼容
    //获取兼容字符串
    for (i = 0; i < _UDE[0].length; i++) {
        for (j = 0; j < _UDE[1].length; j++) {
            if (_UFE = window[_UDE[1][j] + (j ? _UDE[0][i].replace(/\b(\w)|\s(\w)/g, function (e) { //通过循环和获取 每次获取的时候利用首字母大写设置
                return e.toUpperCase();
            }) : _UDE[0][i]) + "AnimationFrame"]) { _UDE[0][i] = _UFE; break; };
        }
    }
    _UDE = _UDE[0];
    (typeof _UDE[0] == "string") && (_UDE[0] = _UDE[1] = null);
    return _UDE;
}

/**
* 获取鼠标位置
*
* @param  {object} 对象 
*/
U.UF.C.Animation.init = function (UDE, USE) {//动画初始化
    U.UF.C.AddObj(this, UDE); //添加动画对象
    this.type = USE || U.UF.C.Animation.get();
    this.sm = (USE && USE[0]) ? new Date() : Math.ceil(this.ti / 20); //动画开始的时间  
    this.start(USE); //开始动画
}

//动画方法
U.UF.C.Animation.init.prototype = {
    start: function (USE) {//这里开始了动画 
        var _UFN = (USE || this.type)[0];
        this.tm = (_UFN ? _UFN(function(){this.time();}) : window.setInterval(function(){this.time(true);}, 20)); //动画使用开始
    },
    time: function (UTF) {//动画运行
        var _UTI, _UJT, _UST;
        if (UTF == true) { //普通计时器动画
            _UTI = 20 / this.ti;
            (this.ti <= 0) && (this.stop(), _UTI = null);
            this.cb(_UTI); this.ti -= 20;
        }
        else {//利用重绘动画使用
            _UTI = new Date(); //据偶去当前的时间
            _UJT = _UTI - this.sm;
            _UST = _UJT / this.ti;
            this.sm = _UTI; //时间的变化
            this.ti -= _UJT; //总时间的减少
            (this.ti <= 0) && (_UST = null, this.stop()); //调用停止函数
            (_UST !== 0) && (this.cb(_UST)); //结束的回调
            (_UST !== null) && (this.start()); //重复调用
        }
    },
    stop: function () {//动画结束
        (this.type[1] || window.clearInterval)(this.tm);
    }
}


/**
* HTML模版页面 支持js内置 类似于js上的php ejs
*
* @param  {element} 需要变化的元素
* @param  {object} 传参对象
*/
U.UF.C.Simulation = function (UDOD, UDE) {
    new U.UF.C.Simulation.init(UDOD, UDE).exec();
}

/**
* 初始化HTML模版页面 支持js内置 类似于js上的php ejs
*
* @param  {element} 需要变化的元素
* @param  {object} 传参对象
*/
U.UF.C.Simulation.init = function (UDOD, UDE) {
    this.el = UDOD; //
    U.UF.C.AddObj(this, UDE);
    return this;
}

U.UF.C.Simulation.init.prototype = {
    //正则配置
    config: { m: /^\\<{+([\s\S])+\\}>$/, //  /\+=([\s\S])+?\+$/g
        zs: "+=", ze: "+", c: /\\/g,
        d: /(?=["])/g, s: "<{", e: "}>",
        f: "%",
        t: "([\\s\\S])*?"
    },
    //执行
    exec: function () {
        try {
            var i, _UCS = "",
            _UPE = [],
            _UT = this,
            _UKE = this.key,
            _UCE = this.config,
            _USE = (this.el.innerHTML || this.el).trim(" ").replace(_UCE.c, "\\\\").replace(_UCE.d, "\\").replace(this.getConfig("\\\\", "", "", "\\\\"),
            function (UST) { //配置输出查看 
                return UST.replace("\\" + _UCE.s, _UCE.s.replaceHtmlSign()).replace("\\" + _UCE.e, _UCE.e.replaceHtmlSign());
            });

            //函数匹配区域
            _USE = _USE.replace(this.getConfig("", "", _UCE.f), function (UST) {
                return UST.replace(_UCE.s + _UCE.f, "\";").replace(_UCE.e, ";uhtml+=\"");
            });

            _USE = _USE.replace(this.getConfig(), function (UST) {
                return "\"+" + ((UST.replace(_UCE.s, "").replace(_UCE.e, "").replace(_UT.re("\\" + _UCE.zs + _UCE.t + "\\" + _UCE.ze),
                function (UST) {
                    return UST.replace(_UCE.zs, "").replace(_UCE.ze, "").replaceHtmlSign();
                })) || "\"\"") + "+\"";
            }); //配置html输出区域
            _USE = 'var uhtml="' + _USE + '"; return uhtml;';

            //变量传参
            if (_UKE) {
                for (i in _UKE) {
                    (_UKE.hasOwnProperty(i)) && (_UCS += (_UCS ? "," : "") + i, _UPE.push(_UKE[i]));
                }
            };
            _USE = Function(_UCS, _USE).apply(this.that || this, _UPE); //利用函数执行回调处理
            (this.cb) && (this.cb(_USE)); //获取模版回调
        }
        catch (e) { throw new Error(e); }
    },
    /**
    * 获取正则
    *
    * @param  {string} 正则字符串
    */
    re: function (URE) {
        return new RegExp(URE, "g");
    },
    /**
    * 初始化HTML模版页面 支持js内置 类似于js上的php ejs
    *
    * @param  {string} 正则开头
    * @param  {string} 正则结束
    * @param  {string} 正则中间的内容
    * @param  {string} 正则结束的内容
    * @return  {string} 正则内容
    */
    getConfig: function (US, UE, UOS, UOE) { //获取系统配置
        var _UCE = this.config;
        return this.re((US || "") + _UCE.s + (UOS || "") + _UCE.t + (UOE || "") + _UCE.e + (UE || ""));
    },
    getHtml: function () { //获取生成的html代码

    },
    /**
    * 正则对象
    *
    * @param  {object} 正则设置
    */
    set: function (UDE) { //设置config
        var i, _UCE = this.config;
        for (i in _UCE) {
            (UDE.hasOwnProperty(i)) && (UDE[i] = _UCE[i]);
        }
        return this;
    }
}



//#region 处理了用户是否活动在当前页面的处理，当用户活动到当前页面的时候则五秒刷继续运行，当用户没有聚焦五秒刷取消

///**
//*用户页面状态使用次数 统计页面计数 配合统一账号 同一浏览器多登问题
//*本地存储方式进行存储数据 不污染cookie
//*/
//U.MD.D.record = function () {
//    //本地存储需要有一套完整的数据结构及方案。暂时放这里，没用到。
//    U.MD.D.LocalStorage = U.DW.local(); //初始化本地存储
//    U.MD.D.LocalStorage.set("user", { value: "" }); //设置用户访问值
//    U.MD.D.LocalStorage.remove("fm"); //清除前面记录
//    U.MD.D.LocalStorage.set("ati", Number(U.MD.D.LocalStorage.get("ati") || 0) + 1); //添加页面访问值
//}

///**
//* 页面聚焦使用
//*/
//U.MD.D.focus = function () {
//    U.MD.D.LocalStorage.off();    //取消页面消息通知
//    U.MD.C.T.onesetInterval();    //启动页面数据更新
//}

///**
//* 页面失去焦点使用
//*/
//U.MD.D.blur = function () {
//    U.MD.D.LocalStorage.on(U.MD.D.Asynblur);    //重新检视页面
//    if (U.MD.D.LocalStorage.get("ati") > 0) {
//        U.MD.C.T.ClearInterval();    //清理页面数据获取
//    }
//}

///**
//* 这里为数据异步 使得各个页面 共享数据 一个浏览器允许多登 数据共享处理
//*/
//U.MD.D.Asynblur = function (errorobj) {
//    var _userid = US.userInfo.userid; //用户ID
//    var _value = U.UF.C.strToJson(errorobj["newValue"]); //获取页面值
//    if (U.MD.D.LocalStorage.get("ati") > 0) { //如果活动数大于0 停止这个页面活动
//        U.MD.C.T.ClearInterval();
//    }
//    else { //页面活动设置
//        U.MD.C.T.onesetInterval();
//    }
//    //数据共享分类处理
//    switch (errorobj.key) {
//        case "fm": //好友消息数据共享处理
//            if (_value.uid == _userid) {
//                U.MD.F.N.asynMessageService(_value, true);
//            }
//            break;
//        case "user": //用户数据
//            if ((_value.uid == _userid) && _value.value == "upline") {
//                U.MD.U.LO.emptyUserInfo();
//            }
//            break;
//    }
//}

//#endregion




//#region 错误区域,需要在界面中显示，如何显示，先设计，后制作功能。然后重写一个函数，不需要类。

//错误区域初始化
U.A.Error = function () {
    return new U.A.Error.init();
}

//生成错误对象 错误对象的实例
U.A.Error.init = function () {
    this.State = this.LogID = this.Value = this.Dt = this.Type = null;
}

U.A.Error.init.prototype = {
    /**
    * 判断对象是否为错误对象
    *
    * @return  {object} json值
    */
    isError: function (UDE) {
        if (U.UF.C.isObject(UDE)) { //判断是否为对象
            for (var i in this) { if (this.hasOwnProperty(i) && !(i in UDE)) { return false; } }
            return true;
        }
        return false;
    },

    /**
    * 设置错误
    *
    * @return  {object} 错误值
    */
    set: function (UDE) {
        U.UF.C.AddObj(this, UDE); //根据错误值添加错误
        return this;
    }
}

//#endregion





//#region ajax post请求

/**
* post请求
* @param  {object} 传参
----------[url] 请求的地址
----------[parameter] 请求的参数
----------[_context] 请求的回调参数
----------[cb] 回调函数
* @return  {object} post对象
*/
U.A.Post = $.Post = function (UDE) {
    var _UTE = new U.A.Post.init(UDE); //初始化对象
    _UTE.send(); //发送请求
    return _UTE;
}

/**
* 初始化post对象
*
*/
U.A.Post.init = function (UDE) {
    U.UF.C.AddObj(this, UDE);
}

U.A.Post.init.prototype = {
    //发送请求
    send: function () {
        var i, _UDE = [],
            _URL = this.url, //请求的地址
            _UPE = this.parameter, //请求参数
            _UCE = this.context; //请求传参
        //添加参数
        if (_UPE) {
            for (i in _UPE) {
                if (_UPE.hasOwnProperty(i)) {
                    _UDE.push($$("input", { "name": i, "value": _UPE[i] }));
                }
            }
        }
        //发送消息
        U.UF.UP.inputUpload(_UDE, U.UF.C.apply(this, function () { this.success(); }), _UCE, _URL, null, "application/x-www-form-urlencoded");
    },
    /**
    * psot请求成功回调
    * @param  {object} 数据
    */
    success: function (UDE) { //异步回调
        (this.cb) && (this.cb(UDE));
    }
}

//#endregion



/**
* 把json字符串转化成json
*
* @param  {string} 需要判断的对象
* @return  {object} 返回成功过生成后的对象 支持无线树
*/
U.UF.C.strToJson = function (obj) {
    //obj json字符串
    var i; //循环初始化

    if (U.UF.C.isString(obj)) {
        obj = obj.parseJSON();
    }
    if (Array.isArray(obj)) { //设置数组  
        for (i = 0; i < obj.length; i++) {
            if (U.UF.C.isString(obj[i])) {
                obj[i] = obj[i].parseJSON();
            }
            if (Array.isArray(obj[i])) {
                U.UF.C.strToJson(obj[i]);
            }
        }
    }
    return obj;
}


//暂时先屏蔽 网上很少使用
//outerText 最初是由 IE4.0 浏览器实现的私有属性,只有 Firefox 不支持该属性
//兼容outerText
//        if (!!document.getBoxObjectFor || window.mozInnerScreenX != null) {//判断是否为firefox 
//            HTMLElement.prototype.__defineSetter__("outerText", function (str) {
//                var parsedText = document.createTextNode(str); //创建文本节点
//                this.parentNode.replaceChild(parsedText, this); //用创建的文本节点代替this
//                return parsedText;
//            });
//            HTMLElement.prototype.__defineGetter__("outerText", function () {
//                var r = this.ownerDocument.createRange(); //在这个元素的根元素创建一个(Range 对象)
//                r.selectNodeContents(this); //设置该范围的边界点，使它包含指定节点的子孙节点，但不包含指定的节点本身;参数->其子节点将成为当前范围的内容的节点
//                return r.toString(); //把一个逻辑值转换成字符串,并返回结果
//            });
//        }
//暂时先屏蔽
//        if (!("componentFromPoint" in HTMLElement.prototype)) {//通过特定事件返回对象在指定坐标下的位置  
//            U.UF.EV.boundProperties(HTMLElement.prototype, "componentFromPoint", function () {//componentFromPoint("指定x的客户端窗口的坐标","指定y的客户端窗口的坐标")
//                return function () {
//                    var _UE = U.UF.C.GetMousep();
//                    var _UDE = U.UF.EL.getElementInfo(this);
//                    if ((_UE["X"] > _UDE["CW"] + _UDE["TX"]) || (_UE["Y"] > _UDE["CH"] + _UDE["TY"])) {
//                        return "outside";
//                    }
//                    return "";
//                }
//            },
//        function () { });
//        }

//IE的script元素支持onreadystatechange事件,不支持onload事件.
//FF的script元素不支持onreadystatechange事件,只支持onload事件.
//        if (!("onreadystatechange" in HTMLElement.prototype)) {//判断是否是firefox
//            U.UF.EV.boundProperties(HTMLElement.prototype, "onreadystatechange", function () {
//                return this.onload;
//            },
//        function (cb) {
//            this.onload = cb;
//        });
//        }
//        function loadJS(url, success) {
//            var domScript = document.createElement('script');
//            domScript.src = url;
//            success = success || function () { };
//            domScript.onload = domScript.onreadystatechange = function () {
//                if (!this.readyState || 'loaded' === this.readyState || 'complete' === this.readyState) {
//                    success();
//                    this.onload = this.onreadystatechange = null;
//                    this.parentNode.removeChild(this);
//                }
//            }
//            document.getElementsByTagName('head')[0].appendChild(domScript);
//        }        
//        if (!("setCapture" in HTMLElement.prototype)) {//判断是否是firefox
//            U.UF.EV.boundProperties(HTMLElement.prototype, "setCapture", function () {
//                return function () { window.captureEvents(Event.MOUSEMOVE); } //firefox对于鼠标事件的捕捉
//            },
//        function () { });        }
//       
//        if (!("releaseCapture" in HTMLElement.prototype)) {//判断是否是firefox
//            U.UF.EV.boundProperties(HTMLElement.prototype, "releaseCapture", function () {
//                return function () {
//                    window.releaseEvents(Event.MOUSEMOVE); 
//                }
//            },
//        function () { });
//        }
//setCapture和window.captureEvents(Event.MOUSEMOVE)的兼容

//        if (!("event" in window.constructor.prototype)) {/*检测浏览器是否支持鼠标键盘事件*/
//            U.UF.EV.boundProperties(window.constructor.prototype, "event", function () {
//                var _UDE = arguments.callee; //arguments.callee ->指向参数arguments对象的函数
//                while (_UDE.caller) {//一直往上寻找直到 寻找到顶层作用域 返回null 再往下执行
//                    _UDE = _UDE.caller;
//                }
//                return _UDE.arguments ? _UDE.arguments[0] : null; //arguments 是一个对应于传递给函数的参数的类数组对象。
//            }, function () { });
//        }

//            if (!("srcElement" in window.Event.prototype)) {
//                U.UF.EV.boundProperties(window.Event.prototype, "srcElement", function () {
//                    return event.target;
//                },
//        function () { });
//            }
//srcElement 和 target 的兼容
//            var theEvent = window.event || arguments.callee.caller.arguments[0]; //arguments.callee.caller.arguments[0]相当于firefox的获取event
//            var srcElement = theEvent.srcElement; //捕获当前事件作用的对象
//            if (!srcElement) {//Firefox不兼容srcElement
//                srcElement = theEvent.target; //Firefox兼容target
//            }

//            if (!("keyCode" in window.Event.prototype)) {
//                U.UF.EV.boundProperties(window.Event.prototype, "keyCode", function () {
//                    return event.which;
//                },
//        function () { });
//            }
//keyCode - 兼容chrom和Firefox

//        HTMLElement.prototype.__defineGetter__("onmousewheel", function () {
//            return this.onwheel;
//        });
//        HTMLElement.prototype.__defineSetter__("onmousewheel", function (cb) {
//            this.onwheel = cb;
//        });
//        if (!("onmousewheel" in HTMLElement)) {
//            if ("onwheel" in HTMLElement.prototype) {
//                U.UF.EV.boundProperties(HTMLElement.prototype, "onmousewheel", function () {
//                    return this.onwheel;
//                },
//            function (cb) {
//                this.onwheel = cb;
//            });
//            }
//            else {
//                //firefox支持onmousewheel
//                if (browser.firefox) {
//                    (function () {
//                        window.addEventListener("DOMMouseScroll", function (UE) {
//                            //监控Scroll事件
//                            var _UOE = null
//                          , _UDOD = UE.srcElement;  
//                            do {
//                                _UOE = U.selectEl(_UDOD).attr("onmousewheel") || _UDOD.onmousewheel;
//                                _UDOD = U.selectEl(_UDOD).Parent();
//                            } while (!(_UOE || !_UDOD)); //冒泡的顶部获取
//                            if (_UOE) {
//                                (typeof _UOE == "string") && (_UDOD.onmousewheel = new Function(_UOE));
//                                U.M.StopDefault();
//                                //阻止页面固定事件
//                                setTimeout(function () {
//                                    _UOE.call(this, UE);
//                                }
//                            , 0);
//                                //异步执行 解决锁定的bug
//                            }
//                        }
//                    , false);
//                    }
//                )();
//                }
//            }
//        }
//------------------------------------------------------------------------------------------
//        if (!("innerText" in HTMLElement.prototype)) {/*检测浏览器是否支持innerText这个方法*/
//            U.UF.EV.boundProperties(HTMLElement.prototype, "innerText",
//              function () {
//                  return this.textContent;
//              },
//               function (UDE) {
//                   this.textContent = UDE;
//               }
//        );
//        }
//------------------------------------------------------------------------------------------
//        if (!("outerHTML" in HTMLElement.prototype)) {/*检测浏览器是否支持outerHTML这个方法*/
//            U.UF.EV.boundProperties(HTMLElement.prototype, "outerHTML",
//            function () {
//                var _UDOD = this.cloneNode(true),
//                _UDTD = $$("div", {});
//                _UDTD.appendChild(_UDOD);
//                return _UDTD.innerHTML; /*如果不支持就使用innerhtml插入*/
//            },
//             function (UTH) {
//                 var i, _UDOD = U.selectEl(this), _UDPD = _UDOD.Parent(), _UDCD = $$("div", {
//                     "innerHTML": UTH
//                 }).childNodes, _UDTD = document.createDocumentFragment;
//                 for (i = 0; i < _UDCD.length; i++) {
//                     _UDTD.appendChild(_UDCD[i]);
//                 }
//                 ; _UDTD.insertBefore(_UDTD, this);
//                 _UDOD.remove();
//             }
//        );
//         }
//------------------------------------------------------------------------------------------
//        if (!("outerText" in HTMLElement.prototype)) {/*检测浏览器是否支持outerText这个方法*/
//            U.UF.EV.boundProperties(HTMLElement.prototype, "outerText",
//           function () {
//               var _UDOD = this.cloneNode(true)
//                      , _UDTD = $$("div", {});
//               _UDTD.appendChld(_UDOD);
//               return _UDTD.innerText; /*如果不支持就使用innerText插入*/
//           },
//          function (UTH) {
//              var i, _UDOD = U.selectEl(this), _UDPD = _UDOD.Parent(), _UDCD = $$("div", {
//                  "innerText": UTH
//              }).childNodes, _UDTD = document.createDocumentFragment;
//              for (i = 0; i < _UDCD.length; i++) {
//                  _UDTD.appendChild(_UDCD[i]);
//              }
//              _UDTD.insertBefore(_UDTD, this);
//              _UDOD.remove();
//          });
//        }
//------------------------------------------------------------------------------------------
//        if (!("currentStyle" in HTMLElement.prototype)) {
//            U.UF.EV.boundProperties(HTMLElement.prototype, "currentStyle", function () {
//                return getComputedStyle(this, false);
//            },
//        function () { });
//        }
//------------------------------------------------------------------------------------------
//        if (!("onresize" in HTMLElement.prototype) || !browser.msie) {//HTMLElement.prototype内没有onresize 则执行这个函数 
//            U.UF.CP.onresize = function (UDOD, UDTD, cb) {
//                Size事件设置
//                if (cb) {
//                    UDOD.contentDocument.defaultView.onresize = function () { U.UF.C.apply(UDTD, [[cb]])(); }  //
//                }
//                else {
//                    try {
//                        delete this.__SizeElement__;
//                    } catch (e) { }
//                }
//            }
//            U.UF.EV.boundProperties(HTMLElement.prototype, "onresize", function () {
//                try {
//                    this.__SizeElement__.contentDocument.defaultView.onresize;
//                } catch (e) {
//                    return null;
//                }
//            },
//        function (cb) {
//            if (this.tagName) {
//                设置Set事件
//                var _UDOD = this.__SizeElement__;
//                (U.UF.EL.getStyle(this, "position") == "static") && (this.style.position = "relative");
//                if (!_UDOD || U.selectEl(_UDOD).Parent() != this && cb) {
//                    _UDOD = this.__SizeElement__ = $$("object", {
//                        "onload": function(){U.UF.CP.onresize(this, this, cb);},
//                        "type": "text/html",
//                        "data": "about:blank",
//                        "style": {
//                            "cssText": "display:block;position:absolute;top:0;left:0;height:100%;width:100%;overflow:hidden;pointer-events:none;z-index:-1;visibility:hidden;margin:0;padding:0;"
//                        }
//                    }, this)[0];
//                }
//                else {
//                    U.UF.CP.onresize(_UDOD, this, cb);
//                }
//            }
//        });
//        }
//        if (!("componentFromPoint" in HTMLElement.prototype)) {   // --------- 上面有重复代码
//            U.UF.EV.boundProperties(HTMLElement.prototype, "componentFromPoint", function () {
//                return function () {
//                    var _UE = U.UF.EL.getMousePosition();
//                    var _UDE = U.UF.EL.getElementInfo(this);
//                    if ((_UE["X"] > _UDE["CW"] + _UDE["TX"]) || (_UE["Y"] > _UDE["CH"] + _UDE["TY"])) {
//                        return "outside";
//                    }
//                    return "";
//                }
//            },
//        function () { });
//        }



/**
* loading变化设置
* @param  {element} 当前loading元素
*/
/*U.UF.DL.loading.Donresize = function (UDOD, UDTD, UTF) {
    if (UDOD["P"] > -1) { //loading变化设置
        var _UDAD = U.selectEl("div", UDOD),
        _UH = U.selectEl(UDOD).height() - _UDAD[0].offsetHeight; //loading大小变化
        _UDAD[0].style.top = (_UH > 0 ? _UH : 0) / 2 + "px"; //loading图片位置设定
    }
    else { //取消loading
        U.UF.DL.uploading(UDOD);
    }
}*/

/**
* 取消loading
* @param  {element} 当前loading元素
*/
/*U.UF.DL.uploading = function (UDOD) {
UDOD = UDOD[0] || UDOD; //需要loading元素
var i, _UAE = ["__ULOADElement__", "__UCS__"], //loading元素遗留参数
_UDTD = UDOD[_UAE[0]],  //loading
_UME = UDOD[_UAE[1]], //需loading元素原样式
_UCE = UDOD.style,
_UDE = { "width": "0px", "height": "0px", "overflow": "hidden", "padding": "0px", "borderWidth": "0px", "minHeight": "0px", "minWidth": "0px" }; //元素变回参数
//判断元素是否已经可以结束loading
if (_UDTD && ((_UDTD["P"]--) == 0)) {
for (i in _UDE) {
if (_UDE.hasOwnProperty(i)) {
//设置或者取消原参数
if (_UDE[i] == _UCE[i]) { _UDE[i] = _UME[i]; }
else { delete _UDE[i]; }
}
};
UDOD["__UCS__"] = null; //设置样式
$(_UDTD).remove(); //移除loading
$(UDOD).addAttrArray({ "style": _UDE }); //原loading元素样式回归
//清除残留参数
try { delete UDOD[_UAE[0]]; delete UDOD[_UAE[1]] }
catch (e) {
UDOD.removeAttribute(_UAE[0]);
UDOD.removeAttribute(_UAE[1]);
} return true;
}
}*/


////#region 出让命名空间

////出让命名空间
////只有外部项目才会使用 为了和其他框架兼容的方案
//$.noConflict = function (UDE) {
//    var _UDE = window.U.Json_;
//    if (_UDE && _UDE != $) {
//        window.U.Json_ = window.$; window.$ = _UDE;
//        return window.U.Json_;
//    }
//    return $;
//}

////#endregion

    //    filter: function (UTF, UDE) {//结果集筛选
//        UDE = UDE || this; var _UTF, _UCE = [], j, i = 0; if (typeof UTF == "string") { UTF = this.getValue(UTF) } //处理制定的选择 转化成可识别选择
//        for (i = 0; i < this.length; i++) {
//            for (j in UTF) { if (UTF.hasOwnProperty(j)) { if (this[i][j] != UTF[j]) { break; } } }
//            (this[i][j] == UTF[j]) && (_UCE.push(this[i]));
//        }
//        return U.select().osadd(_UCE); //添加子元素到制定的位置
//    },
    //    siblings: function (UIE) { //当前元素所有的兄弟节点
//        var i, _UDE = ["preva", "next"], _UAE = U.select();
//        for (i = 0; i < _UDE.length; i++) { this.celement(_UDE[i] + "All", UIE, _UAE); }
//        return _UAE
//    },
//    celement: function (UTP, UIE, UAE) { //获取元素
//        var _UDOD, j, i = UIE || 0, _UL = UIE + 1 || this.length, _UTF = { "prevaAll": "previousSibling", "nextAll": "nextSibling"}[UTP]; UTP = _UTF || UTP; UAE = UAE || U.select();
//        for (i = 0; i < _UL; i++) { //获取指定元素结果
//            j = 1; _UDOD = this[i]; while ((j > 0 || (_UTF && _UDOD)) && _UDOD[UTP]) {
//                do { _UDOD = _UDOD[UTP]; }
//                while (_UDOD && _UDOD.nodeType !== 1);
//                (_UDOD) && (UAE[UAE.length++] = _UDOD);
//                j--;
//            }
//        }
//        return UAE;
//    },
//    ofparent: function (UIE, UTF) {//获取offsetParent
//        var i = UIE || 0, _UL = UIE + 1 || this.length, UAE = U.select();
//        for (i = 0; i < _UL; i++) { UAE[UAE.length++] = U.UF.EL.offsetParent(this[i]); }
//        return UAE;
//    },
    //    prevaAll: function (UIE) {//当前元素之前所有的兄弟节点
//        return this.celement("prevaAll", UIE);
//    },
//    nextAll: function (UIE) { //当前元素之后所有的兄弟节点
//        return this.celement("nextAll", UIE);
//    },
//    replaceAll: function (UDE, UIE) {
//        var _UME, i = UIE || 0, _UL = UIE + 1 || 1;
//        for (; i < _UL; i++) {
//            if (U.UF.C.isString(UDE)) { _UME = $$(UDE); } else { _UME = U.select(UDE).clone(true); }
//            this.Parent(1, i).replaceChild(this[i], _UME);
//        }
//    },
//    even: function () { //获取偶数元素
//        return this.Auxiliary.selectel("even", this);
//    },
//    odd: function () { //获取奇数元素
//        return this.Auxiliary.selectel("odd", this);
//    },
//    eq: function (UIE) { //索引制定位置的元素
//        return this.Auxiliary.selectel("=" + UIE, this);
//    },
//    gt: function (UIE) { //索引大于的元素
//        return this.Auxiliary.selectel(">" + UIE, this);
//    },
//    lt: function (UIE) {//索引小于的元素
//        return this.Auxiliary.selectel("<" + UIE, this);
//    },
//    each: function (cb, UDE) { //遍历数据
//        if (cb) { var i; UDE = UDE || this; for (i = 0; i < UDE.length; i++) { cb(i, UDE[i]); } }
//    },
//    only: function (UIE) { //选择没有兄弟节点的元素
//        var i, j, _UCE, _UPE, UL = UIE + 1 || this.length;
//        for (i = 0; i < UL; i++) { _UCE = this.parentElement(1, i).Child(); (_UCE.length != 1 || _UCE[0] != this[i]) && (this.del(i, true)); }
//        this.del(); return this;
//    },
//    checked: function (UIE) {//获取所有给单选或者复选的元素
//        var _UCE, j, i = UIE || 0, _UL = UIE + 1 || this.length, _UVE = U.select();
//        for (i = 0; i < _UL; i++) {
//            _UCE = U.select("input@type=checkbox", this[i]); //获取复选框
//            for (j = 0; j < _UCE.length; j++) { (_UCE[j].checked) && (_UVE.osadd(_UCE[j])); } //添加所有给复选的元素
//        }
//        return _UVE;
//    },
//    selected: function (UIE) {//获取下拉列表中给选择的元素
//        var _UCE, j, i = UIE || 0, _UL = UIE + 1 || this.length, _UVE = U.select();
//        for (i = 0; i < _UL; i++) { }
//    },
//    before: function (UDOD, UIE) { //被选择元素前插入指定元素
//        var i = UIE || 0, _UL = (UIE || 0) + 1;
//        for (; i < UIE; i++) { this.append(UDOD, i, this[i].firstChild); }
//    },
//    top: function (UIE) { //获取offsetTop
//        return this[UIE || 0].offsetTop;
//    },
//    left: function (UIE) { //获取offsetLeft
//        return this[UIE || 0].offsetLeft;
//    },
//    width: function (UIE) {//获取长
//        return U.UF.EL.getElementRealWidth(this[UIE || 0]);
//    },
//    innerWidth: function (UIE) { //获取内宽度 包含padding
//        return this[UIE || 0].clientWidth;
//    },
//    outerWidth: function (UIE, UTF) { //获取整体宽度 包含 padding border ture包含margin
//        this[UIE || 0].offsetWidth + this.css("marginLeft") + this.css("marginRight");
//    },
//    height: function (UIE) { //获取宽
//        return U.UF.EL.getElementRealHeight(this[UIE || 0]);
//    },
//    innerHeight: function () { //内高度
//        return this[UIE || 0].clientHeight;
//    },
//    outerHeight: function () { //外高度
//        this[UIE || 0].offsetWidth + this.css("marginTop") + this.css("marginBottom");
//    },
//    replaceC: function (UDOD, UIE) { //元素顶替
//        UIE = UIE || 0; var _UDPD, _UDTD = this[UIE];
//        if (_UDTD) { _UDPD = this.Parent(1, UIE); (_UDPD) && (_UDPD.replaceChild(UDOD, _UDTD)); this[UIE] = UDOD; }; return this;
//    },
//    html: function (UHT, UIE) { return UHT != null ? this.addAttrArray({ "innerHTML": UHT }, UIE) : this[UIE || 0].innerHTML; }, //获取innerhtml
//    text: function (UHT, UIE) { return UHT != null ? this.addAttrArray({ "innerText": UHT }, UIE) : this[UIE || 0].innerText; }, //获取innerText
   
   //    getBackgroundColor: function (UDE) { //获取设置背景图片
//        if (U.UF.C.isString(UDE)) { }
//        else if (Array.isArray(UDE)) { }
//    },
//    first: function () { //获取结果里的第一个元素
//        return U.select(this[0]);
//    },
//    last: function () { //获取最后一个元素
//        return U.select(this[this.length - 1]);
//    },
//    transition: function (UDE, USP, cb, UIE) { //过度动画使用
//        var i, j, _UDW, _UTP, _UFN, _UAE = {}, _UHE = {}, _UME = [["scale", ""], ["translate,perspective", "px"], ["skew,rotate", "deg"]], _UCE = U.UF.EL.GCssAe(); //scale
//        if (_UCE) {//Html5兼容
//            _UTP = _UCE[2] + "transform"; _UAE[_UTP] = "";
//            _UFN: for (i in UDE) {
//                for (j = 0; j < _UME.length; j++) { if (_UME[j][0].split(",").indexOf(i) > -1) { _UDW = _UME[j][1]; _UAE[_UTP] += i + "(" + UDE[i] + _UDW + ") "; continue _UFN; } }
//                _UHE[_UTP + "-" + i] = UDE[i];
//            }
//            this.addAttrArray({ "style": _UHE }).animate(_UAE, USP, cb, UIE); //执行动画
//        }
//    },
//    slideToggle: function (UST, cb, UIE, UTF) {//滑动效果
//        var j, _UTP, _UDE, _USC, i = UIE || 0, _UL = UIE + 1 || this.length, _USE = { height: "", marginBottom: "", marginTop: "", paddingBottom: "", paddingTop: "", display: "block" }, _UKE = _USE; //变化值
//        for (; i < _UL; i++) { //设置动画
//            _USC = this.css("cssText"); U.Json.Each(_USE,U.UF.C.apply(this, function (UAE, UIE) { if (UIE != "display") { if (UIE == "height") { _USE[UIE] = this.height() + "px"; } else { _USE[UIE] = this.css(UIE, null, i); } } })); //原初始值
//            _UDE = [_USE, { "cssText": "height:0px;margin-top:0;margin-bottom:0;padding-top:0;padding-bottom:0;display:block;overflow:hidden"}]; //初始化隐藏动画
//            if ((_UTP = (UTF === false || (UTF == null && this.css("display", "") == "none")))) { _UDE.reverse(); } //设置显示动画
//            this.addAttrArray({ style: _UDE[0] }, i).animate(_UDE[1], UST, function () { this.Auxiliary.slideToggle(_USC + ";display:" + (_UTP ? "block" : "none"), i, _UL, cb); }, i); //设置出现和取消 
//        }
//    },
//    ready: function (cb) { //添加doc ready函数
//        var _UTF = document.attachEvent ? "readystatechange" : "DOMContentLoaded", _UCB = [];
//        _UCB[0] = U.UF.C.apply(document, function () {
//            U.UF.EV.delElementEvent(_UTF, document, _UCB);
//            cb()
//        });
//        U.UF.EV.addElementEvent(_UTF, document, _UCB[0]);
//    },
//    load: function (cb) { //load加载页面
//        (!this.length) && (this.osadd(window)); var _UFN = function () { this.unbind("load", _UFN, 0); cb(); };
//        this.bind("load", _UFN, 0);
//    },
//    contents: function () { },
//    message: function () { //message 事件绑定

//    },
//    mousedown: function (cb, UTF, UIE) { //左右事件
//        (cb) && (this.bind("mousedown", function () { var _UTF = event.button; _UTF = _UTF == 2 || _UTF == 3; if (!UTF || (UTF == "right" && _UTF) || (UTF == "left" && !_UTF)) { cb(); } }, UIE));
//        return this;
//    },

//把数据库的时间戳转换成可读时间
//1、带一个参数  
//参数一：时间格式  
//   1、javascrpt 自带的时间格式 datetime类型 Sun Mar 04 2018 18:45:54 GMT+0800 (中国标准时间)
//   2、sqlserver 时间格式 /Date(1364812396843)/
//   3、mongodb 时间格式 2018/01/01 01:01:01
//   4、mysql 时间格式 2018-01-01 01:01:01
//   5、nodejs的json时间"2018-03-04T11:14:27.878Z"

//js转换mysql中datetime日期格式为00-00-00 00:00:00,转换后为：2016:11:23 09:09:09格式


//U.UF.D.formatDateToArray = function (UOD, UTF) {
//    var _UTP = typeof UOD == "string",
//        _ude = ["getFullYear", "getMonth", "getDate", "getHours", "getMinutes", "getSeconds"];
//    if (!UOD || !_UTP || (_UTP && UOD.indexOf("Date") > -1)) {
//        UOD = _UTP ? new Date(parseInt(UOD.match(/[0-9]+/g)[0])) : (UOD || new Date());
//        for (i = 0; i < _ude.length; i++) {
//            _ude[i] = UOD[_ude[i]]() + (i == 1 ? 1 : 0);
//            _ude[i] = i > 2 ? _ude[i].prefixInteger() : _ude[i];
//        }
//    } //返回时间
//    else if (_UTP) {
//        UOD = new Date(UOD); //获取当前的时间
//        _ude = U.UF.D.formatDateToArray(UOD, true);
//    } //mysql返回的时间


//    return (UTF ? _ude : _ude.slice(0, 3).join("-") + "  " + _ude.slice(3, 6).join(":")); //返回数据

//    ///Date(1364812396843)/
//    //2018/01/01 01:01:01
//    //2018-01-01 01:01:01
//}

//U.UF.D.formatDateToArray = function (UOD, UTF) {
//    try {
//        var _UTP = typeof UOD == "string",
//        _ude = ["getFullYear", "getMonth", "getDate", "getHours", "getMinutes", "getSeconds"];
//        if (!UOD || !_UTP || (_UTP && UOD.indexOf("Date") > -1)) {
//            UOD = _UTP ? new Date(parseInt(UOD.match(/[0-9]+/g)[0])) : (UOD || new Date());
//            for (i = 0; i < _ude.length; i++) {
//                _ude[i] = UOD[_ude[i]]() + (i == 1 ? 1 : 0);
//                _ude[i] = i > 2 ? _ude[i].prefixInteger() : _ude[i];
//            }
//        } //返回时间
//        else if (_UTP) {
//            UOD = new Date(UOD); //获取当前的时间
//            _ude = U.UF.D.formatDateToArray(UOD, true);
//        } //mysql返回的时间
//        return (UTF ? _ude : _ude.slice(0, 3).join("-") + "  " + _ude.slice(3, 6).join(":")); //返回数据
//    } catch (e) { return UOD; }
//}



/*-----------------------------------------------未使用的函数------------------------------------------*/
//js倒计处理
U.UF.D.DJS = (function () {
    var _UFN = function (UDE, fun) {
        var _UTF = false,
         _UL = UDE.length - 1,
         i = _UL, _UCE = [1, 24, 60, 60];
        for (; i > -1; i--) {
            if (UDE[i] > 0) {
                UDE[i]--; if (i < _UL) {
                    UDE[i + 1] = _UCE[i + 1] - 1;
                } _UTF = !_UTF; break;
            }
        }
        (_UTF) && ((fun) && (fun(UDE)), setTimeout(function () { _UFN(UDE, fun) }, 1000)); //回调计时
    }
    //设置时间
    return function (UTM, fun) {
        var i, j, _UZ,
        _UKE = [60, 60, 24, 1],
        _ude = [],
        _UTS = ((new Date(UTM[0], UTM[1] - 1, UTM[2],
         UTM[3] || 0, UTM[4] || 0,
         UTM[5] || 0)) - (new Date())) / 1000;
        for (i = _UKE.length - 1; i >= 0; i--) {
            _UZ = _UTS;
            for (j = 0; j <= i; j++) {
                j == i ? _UZ %= _UKE[j] : _UZ /= _UKE[j];
            }
            _ude.push(parseInt(_UZ, 10));
        }
        _UFN(_ude, fun); //获取倒计时的时间
    }
})();



/*
* 获取浏览器信息
*
* @return  {boolean} { chrome: true, msie:false, firefox:false, 360ee:true, ver: 36}
*/
//U.UF.CI.Browser = function () {

////    var i,
////    _UAE = U.UF.CI.userAgent,
////    _USE = {},
////    _UVE = U.UF.S.browser, //区分浏览器
////    _UDE = U.UF.S.browsers, //个版本浏览器正则
////    _UCE = ["360ee", "360se", "se", "lbbrowser", "aoyou", "theworld", "worldchrome", "greenbrowser", "qqbrowser", "baidu", "MicroMessenger", "QQ", "AppleWebKit"]; //知名公司浏览器区分
////    //判断浏览器版本
////    for (i in _UDE) {
////        if (_UDE.hasOwnProperty(i)) {
////            _USE[i] = _UDE[i].test(_UAE);
////        }
////    }
////    //各个公司的版本
////    for (i = 0; i < _UCE.length; i++) {
////        if (_UAE.indexOf(_UCE[i]) > 0) {
////            _USE[_UCE[i]] = true;
////            break;
////        }
////    };
////   _USE.ver = _UAE.match(_UVE); //设置版本
////    return _USE; //获取内核和产商

//    _bri= U.UF.CI.userAgent,//浏览器信息
//    _obj = {},//空对象 用于装浏览器信息
//    _bro = U.UF.S.browser, //区分浏览器

//    _arr = ["360ee", "360se", "se", "lbbrowser", "aoyou", "theworld", "worldchrome", "greenbrowser", "qqbrowser", "baidu", "MicroMessenger", "QQ", "AppleWebKit"]; //知名公司浏览器区分

////判断浏览器类型
//    //各个公司的版本
//    for (i = 0; i < _arr.length; i++) {
//       if (_bri.indexOf(_arr[i]) > 0) {
//        _obj[_arr[i]] = true; //如果是对应版本则为true
//        break;//找到对应版本后就不再循环
//        }
//    };

//        _bri= U.UF.CI.userAgent,//浏览器信息
//         _bro = U.UF.S.browser, //区分浏览器
//    _obj.ver = _bri.match(_bro); //设置浏览器版本等信息
//    return _obj; //将信息返回
//};


/**
* 添加或者删除自定义属性
*

*/
/*U.UF.EL.addAttributes = function (arr, name, value) {



    var i, //用于循环
    j, //用于循环
    _UAE,
    _UTP = UTV != null ? "setAttribute" : "removeAttribute"; //判断是设置还是删除属性
    for (i = 0; i < UDE.length; i++) {//
        _UAE = UDE[i];
        if (_UAE) {
            if (UCE && UCE.length) { //训话属性处理
                for (j = 0; j < UCE.length; j++) {
                    _UAE = _UAE[UCE[j]];
                }
            }
            _UAE[_UTP](USN, UTV); //执行删除获取添加属性
        }
    }
}

U.UF.EL.delAttributes = function (arr, name) {
    var i, //用于循环
    j, //用于循环
    _UAE,
    _UTP = UTV != null ? "setAttribute" : "removeAttribute"; //判断是设置还是删除属性
    for (i = 0; i < UDE.length; i++) {//
        _UAE = UDE[i];
        if (_UAE) {
            if (UCE && UCE.length) { //训话属性处理
                for (j = 0; j < UCE.length; j++) {
                    _UAE = _UAE[UCE[j]];
                }
            }
            _UAE[_UTP](USN, UTV); //执行删除获取添加属性
        }
    }
}*/


/**
* 获取元素所使用的样式
*
* @param  {element} 需要获取样式的元素 
* @param  {string} 样式的key 
*/
/*U.UF.EL.getStyle = function (UDOD, UVE) {
if (UDOD && UDOD.style) {
UVE = U.UF.EL.styleConversion(UVE);
return (UDOD.style[UVE] || UVE == "cssText") ? UDOD.style[UVE] : (UDOD.currentStyle ? UDOD.currentStyle[UVE] || "" : "");
}
return ""; //获取js对应的style值
}*/
/**
* 添加删除获取class
*
* @param  {array} 进行操作的对象 
* @param  {string} 确定循环范围 
* @param  {element} 正则表达式 获取字符 
* @param  {string} 获取或删除指令
* @return  {boolean} 是否存在改样式
*/
/*U.UF.C.ARClass = function (UDE, UIE, UCN, UTF) {
var _UCT, //储存对象样式名
_UFT, //储存索引值
_UIF, //储存索引值
i = UIE || 0; //循环初始化
_UL = UIE + 1 || UDE.length, //确定循环范围
_UL = Math.min(_UL, UDE.length);
_UCE = new RegExp("(\\s|^)" + UCN + "(\\s|$)"); //需要索引的值
for (; i < _UL; i++) {
_UCT = UDE[i].className;
_UFT = _UCT.match(_UCE);
if (UTF == "Add") {
(!_UFT) && (UDE[i].className += (_UCT ? " " : "") + UCN); 
} //添加class
else if (UTF == "RE") { //删除class
(_UFT) && (_UIF = _UCT.indexOf(UCN) + UCN.length, UDE[i].className = _UCT.replace(_UCE, (_UIF == _UCT.length || !_UIF) ? "" : " "));
}
}
return _UFT;
}*/

/*
**作用：用于指定的元素进行删除指定的class，如果class存在，那么class就删除，如果class不存则不处理
**参数一：el1进行操作的对象
**参数二：el2获取className的字符
**参数三：str添加或删除指令,添加classname为Add，删除classname为Remove
*/
/*U.UF.C.ARClass = function (el1, el2, str) {
var _Reg = el1.className.match(new RegExp("(\\s|^)" + el2 + "(\\s|$)")); // ( \\s|^ ) 判断前面是否有空格 （\\s | $ ）判断后面是否有空格
var _b = !!(_Reg);  //两个感叹号为转换为布尔值 以方便做判断
if (str == "Add") {//判断是否是添加classname
if (!_b) {//判断元素不存在指定的class
el1.className += " " + el2; //给指定的元素添加指定的class
}
}
if (str == "Remove") {//判断是否删除classname
if (_b) {//判断元素存在指定的class
el1.className = el1.className.replace(new RegExp("(\\s|^)" + el2 + "(\\s|$)"), " "); // replace方法是替换
}
}
}*/


///**
//* 获取css3过渡动画
//*
//* @return  {array} 过渡属性的值
//-----------[0] 过渡的css 
//-----------[1] 过渡的回调函数 
//-----------[2] 兼容的前缀 
//-----------[3] 浏览器过渡的监视属性 
//-----------[4] 浏览器结束的属性 
//*/
//U.UF.EL.GCssAe = function () {
//    var i, //遍历初始化
//    _USE = $$("div").style, //获取div的样式
//    //css兼容的形式
//    _UDE = {
//        "WebkitTransition": ["-webkit-transition", "webkitTransitionEnd", "-webkit-", "webkitRequest", "webkitCancel"], //webkit浏览器的兼容
//        "OTransition": ["-o-transition", "oTransitionEnd", "-o-", "oRequest", "oCancel"], //Op 浏览的兼容
//        "MozTransition": ["-moz-transition", "transitionend", "-moz-", "mozRequest", "mozCancel"], //火狐浏览器的兼容
//        "MsTransform": ["-ms-transition", "transitionend", "-ms-"], //ie低版本的兼容
//        "transition": ["transition", "transitionend", "", "r", "cancel"] //html5的兼容
//    }
//    //循环判断获取
//    for (i in _UDE) {
//        if (_UDE.hasOwnProperty(i) && _USE[i] !== undefined) {
//            _UDE[i].push(i);
//            return _UDE[i];
//        }
//    }
//}



///**
//* css动画异步
//*

//*/
//U.UF.EL.AsynCssEM = function (UDID, UDSD, cb, UIF, UIF) {
//    this.removeClass(UDID, UIF);
//    U.selectEl(UDSD).remove();
//    (cb) && (cb(UIF));
//}



// 窗体全局变量
//U.UF.F.isTop = false;
//U.UF.F._closes = [];
//U.UF.F._index = [];


/*U.UF.F.closefun = function (UDOD) {
U.UF.F._closes.splice(U.UF.F._closes.indexOf(UDOD), 1);
};*/

/**
* 放大窗体
*
* @param  {number} 数字1
* @param  {number} 数字2
* @param  {boolean} 返回数字1是否大于数字2
* @param  {number} 数字2
* @param  {boolean} 返回数字1是否大于数字2
*/
/*U.UF.F.windowZooming = function (UDOD, UDTD, cb, UDOM, UST) {
var _USE, _UCE, _UTE, _UTF = true,
_UDTD = U.selectEl(UDOD),
_UST = UDOD.style,
_UED = U.UF.C.GetPDWH(UDOD),
_UW = US.width,
_UH = US.height;
UDTD = UDTD || (event && event.srcElement); //U.UF.C.getElementInfo(UDOD)
if (_UED["OW"] >= _UW && _UED["OH"] >= _UH) {
_UCE = { "title": "全屏", "onmousedown": UST ? (UST.onmousedown || (UDOM ? UDOM.onmousedown : null)) : null, "style": UST ? UST["style"] || { "width": "80%", "height": "80%", "left": "10%", "top": "10%"} : { "width": "80%", "height": "80%", "left": "10%", "top": "10%"} };
_UTF = false;
}
else {
_UTE = UDOD["style"];
_USE = { "onmousedown": UDOM ? UDOM.onmousedown : null,
"style": { "cssText": _UTE["cssText"] + ";", "width": _UTE.width, "height": _UTE.height, "top": _UTE.top, "left": _UTE.left, "display": "block" }, "width": _UED["CW"], "height": _UED["CH"]
};
_UCE = { "title": "缩小",
"onmousedown": UDOM ? (function(){UDOM.onmousedown], [U.UF.F.DragElement(UDOD, UDTD, cb, UDOM, _USE)}) : null,
"style": { "top": "0px", "left": "0px", "width": (_UW - _UED["PD"][1] - _UED["PD"][3] - _UED["BD"][1] - _UED["BD"][3]) + "px",
"height": (_UH - _UED["PD"][0] - _UED["PD"][2] - _UED["BD"][0] - _UED["BD"][2]) + "px"
}
}; //_UED["PXT"] + _UED["PXL"] +
}
(UDOM) && (UDOM.onmousedown = _UCE.onmousedown);
(UDTD) && ($(UDTD).addAttrArray({ "onclick": [[U.UF.F.windowZooming, [UDOD, UDTD, cb, UDOM, _USE]]], "title": _UCE["title"] })); //拖动  //全屏或者恢复调用
UDOD.style.display = "block";
$(UDOD).animate(_UCE.style, 150, function () {
var _UED = U.UF.C.GetPDWH(UDOD); U.UF.F.withf(cb, [_UED["CW"], UDOD["CH"], _UTF]);
}); //窗体大小设置 //回调大小设置
}*/

//最大化移动窗体
/**
* 放大窗体
*
* @param  {number} 数字1
* @param  {number} 数字2
* @param  {boolean} 返回数字1是否大于数字2
* @param  {number} 数字2
* @param  {boolean} 返回数字1是否大于数字2
*/
/*U.UF.F.DragElement = function (UDOD, UDTD, cb, UDOM, UST) {
if (U.UF.F.DragMouseDown.ST) {
U.UF.F.DragMouseDown.ST.set({ move: function (UTE) { //缩小使用
var _UW = US.width,
_UE = U.UF.C.getMousePosition(UDOD);
(!UST.width) && (UST.width = US.width * 0.8);
(!UST.height) && (UST.height = US.height * 0.8);
U.UF.C.AddObj(UST["style"], {
"top": "0px", "left": Math.min(Math.max((_UE["X"] - UST.width / 2), 0), (_UW - UST.width)) + "px"
});  //设置位置大小
U.UF.F.windowZooming(UDOD, UDTD, cb, UDOM, UST);
(UTE && UTE.move) && (UTE.move = null);  //设置大小
}
});
}
}*/

//窗体最小化
/*U.UF.F.windowMinimize = function (UDOD) {
UDOD = U.selectEl(UDOD);
var i, _UCE, _UW = US.width,
_UH = US.height,
_UGE = UDOD.getElementInfo();
_UDE = { "cssText": UDOD[0].style.cssText, "display": "none" };
UDOD.animate({ "cssText": "overflow:hidden;left:0px;top:" + ((_UH - _UGE["OH"] + 100) / 2) + "px;width:" + (Math.min(_UGE["OW"] / 3, 100)) + "px;height:" + (Math.min(_UGE["OH"] / 3, 100)) + "px;opacity:0.8" }, 200, function(){UDOD.css("cssText", _UDE.cssText]], [UDOD.css, ["display", _UDE.display);});
(parent.U.MD.N) && (setTimeout(function () { parent.U.MD.N.UrlWrite([], ""); }, 0));
}
*/
//关闭窗口
/*U.UF.F.closeWindow = function (UDOD, UTF) {
var _UDTD = U.selectEl(UDOD);
(_UDTD.css("display") != "none") && (_UDTD.fadeIn(150, UTF == "remove" ? function () {
_UDTD.remove(); _UDTD = null;
} : "")); //移除
(parent.U.MD.N && UTF !== true) && (parent.U.MD.N.UrlWrite([], ""));
(U.D && U.MD.D.Tb && U.MD.D.T.taskbars) && (U.MD.D.T.taskbars.close(UDOD)); //异步url重写
(U.UF.F._closes.indexOf(UDOD) == -1) && (U.UF.F._closes.push(UDOD));
setTimeout(function(){U.UF.F.closefun(UDOD);}, 0); //删除处理区
}
*/
//窗口居中
/*U.UF.F.windowTopCenter = function (UDOD, cb) {
var i, _UL, _UT, _UW, _UH,
_UTF = U.selectEl(UDOD).css("display") == "none",
_UDE = U.selectEl(UDOD).addAttrArray({ "style": { "display": "block"} })[0],
_UDPD = U.UF.C.TOSP(UDOD), _UW = _UDPD.offsetWidth || US.width,
_UH = _UDPD.offsetHeight || US.height;
_UL = (_UW - _UDE["offsetWidth"]) / 2 + _UDPD["scrollLeft"];
_UT = (_UH - _UDE["offsetHeight"]) / 2 + _UDPD["scrollTop"];
if (U.UF.F._index[2] && U.UF.F._index[2] !== UDOD && Math.floor(_UL) == U.UF.F._index[2].offsetLeft && Math.ceil(_UT) == U.UF.F._index[2].offsetTop) { _UL += 20; _UT += 20; }
U.UF.F._index[2] = UDOD;
U.UF.F.topWindow($(UDOD).addAttrArray({ "style": { "cssText": "left:" + _UL + "px;top:" + _UT + "px;z-index:" + ((parent.US.ZINDEX ++) + 1)} })[0]);
(U.UF.C.isFunction(cb)) && (cb());
(_UTF && UDOD.onresize) && (UDOD.onresize()); //定位
}*/

//窗体置顶
/*U.UF.F.topWindow = function (UDOD, UTF) {
(U.UF.Ut.isEvent(UDOD)) && (UDOD = null);
UDOD = UDOD || U.UF.F.GetEE();
var i, _UDPD,
_UDE = U.UF.F.getWindow(UDOD);
if (UTF !== true) {
setTimeout(function(){U.UF.F.topWindow(UDOD || _UDE[0], true);}, 0);
}
else {
if (_UDE && _UDE.length) {
for (i = 0; i < _UDE.length; i++) {
if (((_UDPD = U.selectEl(_UDE[i]).Parent()) && (_UDPD == document.body || _UDPD.id == "usestudio-server" || _UDPD.id == "UD_SY")) && U.selectEl(_UDE[i]).attr("__top__") != "false" && (!UTF == true || U.UF.F._closes.indexOf(_UDE[i]) == -1)) { //置顶判断
$(_UDE[i]).addAttrArray({ "style": { "cssText": "z-index:" + (((US || parent.US).ZV++) + 1) + ";display:block"} })
}
};
}
return parent.US.ZINDEX ;
}
}
*/

//获取顶层窗体
/*U.UF.F.getWindow = function (UDOD) {
var i, _UCE = [],
_UDTD = UDOD,
_UDBD = document.body,
_UDSD = U.selectEl("#UD_SY")[0] || U.selectEl("#usestudio-server")[0] || _UDBD;
if (_UDSD) {
while ((_UDTD = U.UF.C.TOSP(_UDTD, true, "absolute")) && (_UDTD && (_UDTD != _UDSD && _UDTD != _UDBD))) {
_UCE.push(_UDTD);
_UDTD = _UDTD.parentNode;
}
return _UCE; //.slice(0, -1);
}
}*/

//主处理分层次系统
/*U.UF.F.clickTopWindow._UFN = function (cb, UTF) { //处理函数
//页面置顶处理
//  try { this.focus(); } catch (e) { }
if (U.UF.F.isTop) { clearTimeout(U.UF.F.isTop); }
else {
if (UTF && !U.UF.F.isTop) {
U.UF.F.isTop = setTimeout(function () {
(cb || top.U.UF.F.topWindow)(null, true);
U.UF.F.isTop = false;
}, 0); return;
}
else if (!U.UF.F.isTop) {
(cb || top.U.UF.F.topWindow)(null, true);
(event && event.type == "mousedown") && (U.UF.F.isTop = true);
}
else if (U.UF.F.isTop == true) { U.UF.F.isTop = false; }
}
U.UF.F.isTop = setTimeout(function () {
U.UF.F.isTop = false;
}, 0);
}*/


//获取置顶元素
U.UF.F.GetEE = function () {
    var _UE = window.event;
    if (!_UE) { return document.activeElement; }
    return _UE.srcElement;
}


////#region 拉伸窗体

////虚拟框
//U.UF.F.maskFrame = function () {
//    return $$("div", { "style": { "cssText": "width:100%;height:100%;position:absolute;top:0;left:0;"} }, document.body);
//}

///*
//* 拖动框
//*
//* @param  {element} 需要创建虚拟框的元素
//* @param  {object} 元素的位置
//----------参数为getElementInfo 返回值
//*/
//U.UF.F.foundVirtualBox = function (UDOD, UE) {
//    UDOD = U.selectEl(UDOD);
//    UE = UE || UDOD.getElementInfo(); //获取元素的位置
//    return $$("div", { "style": { "cssText": "pointer-events:none;border:2px solid Gray;position:absolute;top:" + (UE["OT"] - 2) + "px;left:" + (UE["OL"] - 2) + "px;width:" + (UE["OW"]) + "px;height:" + (UE["OH"]) + "px;z-index:" + (US.ZINDEX  + 10)} }, UDOD.Parent());
//}

///*
//* 拉伸函数处理
//*
//* @param  {element} 需要拉伸的元素
//* @param  {function} 拉伸回调函数
//----------参数为getElementInfo 返回值
//*/
//U.UF.F.AddOM = function (UDOD, cb) {
//    if (!$(".UD_W_WT", UDOD)[0]) { //拉伸对象不存在
//        var i,
//        _UTE = U.UF.F.RCDG(UDOD, null, cb), //创建拉伸处理
//        _UTP = "UD_W_WT",
//        _UDE = [["H", "up"], ["MR", "right"], ["B", "down"], ["ML", "left"], ["HL", "topright"], ["BR", "bottomright"], ["BL", "bottomleft"], ["HR", "topleft"]], //拉伸所有的监视 和 className 的设置
//        _UDTD = $$("div", { "className": "UD_W_WT" }); //新建立一个容器
//        for (i = 0; i < _UDE.length; i++) { //添加上下左右处理元素
//            $$("div", { "className": _UTP + "_" + _UDE[i][0], "onmousedown": _UTE.set(_UDE[i][1]) }, _UDTD);
//        }
//        UDOD.appendChild(_UDTD); //添加拉伸元素
//    }
//}

///*
//* 拉伸执行
//*
//* @param  {element} 需要拉伸的元素
//* @param  {string} 需要调用的回调
//* @param  {function} 拉伸回调函数
//----------参数为getElementInfo 返回值
//*/
//U.UF.F.RCDG = function (UDOD, UTF, cb) {
//    return new U.UF.F.RCDG.init(UDOD, UTF, cb);
//}

///*
//* 拉伸执行
//*
//* @param  {element} 需要拉伸的元素
//* @param  {string} 需要调用的回调
//* @param  {function} 拉伸回调函数
//*/
//U.UF.F.RCDG.init = function (UDOD, UTF, cb) { //拖动的拉伸
//    /*
//    注释：
//    -----cb 回调函数
//    -----UDOD 拉伸的原函数
//    */
//    U.UF.C.AddObj(this, { cb: cb, UDOD: UDOD });
//    (UTF) && (this.set(UTF)); //设置回调
//}

//U.UF.F.RCDG.init.prototype = {
//    /*
//    * 拉伸执行
//    *
//    * @param  {element} 需要拉伸的元素
//    * @param  {string} 
//    * @param  {function} 拉伸回调函数
//    */
//    set: function (UTF) {
//        var i, _UDMD,
//        _UDOD = this.UDOD,
//        _UE = U.UF.EL.getElementInfo(_UDOD), //当前位置
//        _UDE = [["move", UTF], ["up", "mup"]];
//        if (UTF && event.button != 2 && (_UE["OH"] != US.height || _UE["OW"] != US.width)) { //非右键
//            //内部使用变量设置
//            U.UF.C.AddObj(this, {
//                UMD: (_UDMD = U.UF.F.maskFrame()), //拉伸虚拟框
//                UTF: UTF, //拖动时回调函数
//                UTOD: U.UF.F.foundVirtualBox(_UDOD), //虚拟框
//                E: _UE, //当前的位置大小
//                H: _UE.H, //原高
//                W: _UE.W, //原长
//                T: _UE.OT, //原top
//                L: _UE.OL//原left
//            });
//            this.UTOD.setCapture(); //创建使用的变量

//            //虚拟框和拖动看置顶
//            U.UF.F.topWindow(this.UTOD);
//            U.UF.F.topWindow(_UDMD); //虚拟框

//            //拖动元素监视
//            for (i = 0; i < _UDE.length; i++) {
//                document["onmouse" + _UDE[i][0]] = U.UF.C.apply(this, [[this[_UDE[i][1].toLocaleLowerCase()]]]);
//            }

//            //返回拖动对象
//            return this; //设置拉伸
//        }
//    },
//    //向上拉伸
//    up: function () {
//        var _UE = U.UF.EL.getMousePosition(), //获取鼠标的位置
//        _UT = Math.min(Math.max(_UE["Y"], 0), this.T + this.H - 4), //获取拉伸头部的top位置
//        _UH = this.H + (this.T - _UT); //计算高度
//        U.selectEl(this.UTOD).addAttrArray({ "style": { "cssText": "top:" + (_UT - 2) + "px;height:" + (_UH) + "px"} }); //设置样式
//    },
//    //下面拉伸
//    down: function () {
//        var _UE = U.UF.EL.getMousePosition(); //鼠标所在的位置
//        _UE["Y"] = Math.max(Math.min(_UE["Y"], US.height), this.T); //获取拉伸的位置
//        this.UTOD.style.height = (_UE["Y"] - this.T) + "px"; //拉伸后的大小处理
//    },
//    //左边拉伸
//    left: function () {
//        var _UE = U.UF.EL.getMousePosition(), //鼠标所在的位置
//        _UL = Math.min(Math.max(_UE["X"], 0), this.L + this.W - 4), //左边位置处理
//        _UW = this.W + this.L - _UL; //长度变化
//        U.selectEl(this.UTOD).addAttrArray({ "style": { "cssText": "left:" + (_UL - 2) + "px;width:" + (_UW) + "px"} });
//    },
//    //右边
//    right: function () {
//        var _UE = U.UF.EL.getMousePosition();  //鼠标所在的位置
//        _UE["X"] = Math.max(Math.min(_UE["X"], US.width), this.L); //右边位置处理
//        this.UTOD.style.width = (_UE["X"] - this.L) + "px"; //内容大小处理
//    },
//    //左上
//    topleft: function () {
//        this.up(); //向上拉伸
//        this.left(); //左边拉伸
//    },
//    //右上
//    topright: function () {
//        this.up(); //向上拉伸
//        this.right(); //右边拉伸
//    },
//    //左下
//    bottomleft: function () {
//        this.down(); //向下拉伸
//        this.left(); //向左拉伸
//    },
//    //右下
//    bottomright: function () {
//        this.down(); //向下拉伸
//        this.right(); //右边拉伸
//    },
//    //结束拉伸
//    mup: function () {
//        var i, _UPE = this.E.PD,
//        _UBE = this.E.BD,
//        _UDTD = U.selectEl(this.UTOD), //拉伸元素
//        _UCE = U.UF.EL.getElementInfo(this.UTOD), //拉伸元素的大小
//        _UDE = [_UCE["W"], _UCE["H"]];
//        //设置得到的位置和大小
//        for (i = 0; i < _UPE.length; i++) {
//            _UDE[(i + 1) % 2] -= (_UPE[i] + _UBE[i]);
//        }
//        //设置拉伸元素
//        U.selectEl(this.UDOD).addAttrArray({ "style": { "cssText": "left:" + (_UCE["OL"] + 2) + "px;top:" + (_UCE["OT"] + 2) + "px;width:" + _UDE[0] + "px;height:" + _UDE[1] + "px"} }); //设
//        //清空
//        U.selectEl(_UDTD).remove();
//        _UDTD[0].releaseCapture();
//        document.onmousemove = document.onmouseup = null;
//        U.selectEl(this.UMD).remove();
//        //回调设置
//        U.UF.F.withf(this.cb, _UDE);   //清空 //执行回调              
//    }
//}

///*
//* 回调执行
//*
//* @param  {object} 回调函数或者参数
//* @param  {object} 回调的参数
//*/
//U.UF.F.withf = function (UAE, UDE) {
//    if (UAE) {
//        var i, j, k, _UCE, _UDOD,
//        _UKE = {};
//        for (i in UAE) {
//            if (UAE.hasOwnProperty(i)) {
//                //处理元素共同变化处理 这个会更加最大拖拉的元素 自适应
//                if (i == "with") {
//                    for (j = 0; j < UAE[i].length; j++) {
//                        _UCE = UAE[i][j];
//                        _UDOD = _UCE["Element"]; //获取需要变化的元素集
//                        for (k in _UCE) {
//                            if (_UCE.hasOwnProperty(k) && k != "Element") { //变化的样式处理
//                                _UKE[k] = _UCE[k] + UDE[k == "width" ? 0 : 1];
//                            }
//                        }
//                        U.selectEl(_UDOD).addAttrArray({ style: _UKE });
//                    }
//                }
//                //直接回调自己处理
//                else { U.UF.C.apply(null, UAE[i])(UDE); } //执行回调
//            }
//        }
//    }
//}


////#endregion



/**
* style样式转换 如 text-align => textAlign 或者相反的换
*
* @param  {array} 进行操作的对象 
* @param  {string} 确定循环范围 
*/
/*U.UF.EL.styleConversion = function (UST, UTF) {
UTF = UTF ? [/[A-Z]/g, "-", 0, "toLowerCase"] : [/-[a-z ]/g, "", 1, "toUpperCase"]; //转换的样式或者属性
return UST.replace(UTF[0], function (UMS) { //利用正则转换
return UTF[1] + UMS.charAt(UTF[2])[UTF[3]]();
});
}*/


/**
* 获取鼠标位置
*
* @param  {element} 相对对象 
* @param  {element} 进暂无使用行操作的对象 
* @return  {array} 过渡属性的值
*/
/*U.UF.C.GetMousep = function (UDOD, UDTD) {
var _UE = U.UF.EV.getEventSource(), //获取MouseEvent
_UET = (_UE.touches && _UE.touches[0]) ? _UE.touches[0] : _UE, //如果是手机点击则获取touches[0]对象
_UDE = { "X": _UET.clientX || _UET["pageX"] || 0, "Y": _UET.clientY || _UET["pageY"] || 0 }, //储存坐标的对象
_UGE = { BCRL: 0, PXL: 0, BCRT: 0, PXT: 0 }; //用于储存数据sss

(UDTD || UDOD) && (_UGE = UDTD || U.UF.EL.offsetParent(UDOD, true),
_UGE = U.UF.EL.getElementInfo(_UGE)); //获取相对元素的位置
U.UF.C.AddObj(_UDE, { "TX": _UGE.BCRL - _UGE.PXL, "TY": _UGE.BCRT - _UGE.PXT }); //获取位置与上级相对位置
U.UF.C.AddObj(_UDE, { "X": _UDE["X"] - (_UDE["TX"] || 0), "Y": _UDE["Y"] - (_UDE["TY"] || 0), "MX": _UDE.X, "MY": _UDE.Y }); //设置值
return _UDE;
}*/



///**
//* 统一处理函数,解决闭包添加事件的问题
//* 使用apply，把事件与属性添加到对象上，而不是添加到window顶级对象。使用apply而不是call，是因为apply第二个参数可以传递参数数组，代码更少。
//* 调用方法 U.UF.C.apply(this,'执行函数的事件')  例如 U.UF.C.apply(this,'this.style.display="none"');
//*解决作用域的问题函数名称为:U.FC.C.apply，主要用于在javascript中实现类的功能
//* @param  {object} 将要绑定事件与属性的对象,如没有，可以传递null或者this，此处还需要优化，很多地方都会调用此函数，会导致速度降低。
//* @param  {object} 函数与参数组成的数组。

//案例：U.FC.C.apply(this,function(){});  //this用dialog做案例.
//案例: U.FC.C.apply(element,function(){});
//*/
//U.UF.C.apply = function (retElement, obj) {
//    //retElement 将要绑定事件与属性的对象,如没有，可以传递null或者this，此处还需要优化，很多地方都会调用此函数，会导致速度降低。
//    //obj 时间和属性组成的参数数组
//    return function () {
//        if (obj) {
//            var i, //循环初始化
//            j, //循环初始化
//            _URE,
//            _UAE,
//            _UTE = (retElement) || this,
//            _UME = Array.prototype.slice.apply(arguments); //arguments 转化成数组
//            if (typeof obj == "string") { _URE = (new Function(obj)).apply(_UTE, _UME); }
//            else if (typeof obj == "function") { _URE = obj.apply(_UTE, _UME); }
//            else {
//                for (i = 0; i < obj.length; i++) {
//                    if (obj[i] && obj[i][0]) { //函数存在
//                        _UAE = obj[i][1];
//                        (!_UAE) && (_UAE = []);
//                        (!U.UF.Ut.isEvent(_UME[0]) || _UME.length > 1) && (_UAE = _UAE.concat(_UME)); //event == null ||
//                        //循环添加至
//                        for (j = 0; j < _UAE.length; j++) {
//                            if (typeof _UAE[j] == "string") {
//                                try {
//                                    if (_UAE[j].indexOf(this) > -1 || _UAE[j].indexOf("retElement") > -1 || _UAE[j].indexOf("event") > -1) { _UAE[j] = eval("0,(" + _UAE[j] + ")"); } //制定参数解析
//                                    else if (U.UF.S.Num.test(_UAE[j])) { _UAE[j] = Number(_UAE[j]); } //数字转化
//                                } catch (e) { U.UF.C.console(e); }
//                            }
//                        }
//                        try {
//                            if (U.UF.C.isString(obj[i][0])) {
//                                _URE = eval(obj[i][0]).apply(_UTE, _UAE); //eval效率不高 特殊情况才用
//                            }
//                            else if (U.UF.C.isFunction(obj[i][0])) { _URE = obj[i][0].apply(_UTE, _UAE); }
//                        }
//                        catch (e) { U.UF.C.console(e); } //函数执行错误
//                    }
//                }
//            }

//            return _URE;
//        }
//        //直接掉function(){},不传递obj参数时，返回false。
//        else { return false; }
//    }
//}

/**
* 修改设置制定样式后获取所有设置的元素
*
* @param  {element} 元素 
* @param  {string} 获取的类型 
* @param  {string} 是添加还是移除属性 
-----------De 移除属性
* @param  {object} 设置的属性 
* @return  {array} 通过参数2获取的元素 

*/
/*U.UF.EL.SetElement = function (UDE, UTP, URE, UTF) {
    if (UDE) {
        (typeof (UDE) == "string") && (UDE = $$("div", { "innerHTML": UDE }));
        UDE = UDE || document;
        var i, //用于循环
        _UFT,
        _UAE,
        _UDOD,
        _UMS = "",
        _UCE = [];
        UTP = (UTP == "*" || !UTP) ? "&*" : UTP; //需要获取的值
        if (UTF) {
            for (i in UTF) {
                UTP += ("[" + i + (UTF[i] ? ("=" + UTF[i]) : "") + "]"); //属性选择
            }
        }
        if ((_UAE = U.selectEl(UTP, UDE)) && UTF !== false && URE) { //设置
            _UCE = _UAE[(_UFT = URE == "De") ? "remove" : "addAttrArray"](_UFT ? null : URE);
        }
        (URE == "De") && (_UCE = [_UCE.length > 0 ? _UCE : _UAE, UDE]); //如果为删除返回两个值  一个是选中的值 一个是传入的元素集
        return _UCE;
    }
    return [];
}*/
/*
**  作用：修改设置指定样式后获取所有设置的元素
**  @param {element} el 获取需要修改样式的元素
**  @param {element} key 获取属性的名
**  @param {boolean} b 如果b为true，则设置元素属性
**  @param {element} value 获取属性的value值
**  实例：console.log(U.UF.EL.SetElement($("script")[0], 'key', true, 'value'))//设置属性
**        console.log(U.UF.EL.SetElement($("script")[0], 'key'))//获取属性
*/
U.UF.EL.SetElement = function (el, key, b, value) {
    var i; //  用于循环
    if (el) { //  判断元素是否存在
        if (b === true) { // 如果b为true 则设置元素属性
            el.setAttribute(key, value);
            return el.getAttribute(key) // 返回元素的属性值
        }
        for (i = 0; i < el.attributes.length; i++) { // 循环元素的属性
            if (el.attributes[i].nodeName === key) { // 判断元素的属性名是否跟key相同
                return el.attributes[i].nodeValue // 返回获取的元素的属性值
            }
        }
    }
    return 0
}

/**
* 根据ID获取指定的祖先元素
*
* @param  {element} 当前元素
* @param  {string} 祖先元素的id
* @return  {element} 祖先元素 
*/

/*U.UF.EL.getAncestor = function (UDOD, UTID) {
while (UDOD && !(UDOD == UTID || UDOD.id == UTID)) { //递归寻找父级
UDOD = UDOD.parentNode;
}
return UDOD;
}

        number: /\(([\s\S]*?)\)/, //数字的使用
        ename: /=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*/g, //[]选择符的使用
        escape: /(&|![\w\u00c0-\uFFFF\-]|\@[\w\u00c0-\uFFFF\-]+=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*)/g, //需要转义的正则
        nregular: /[>|+|~]/g, //伪类选择
        con: /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, //通用符的使用
        className: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,  //className的定义
        id: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, //id的定义
        name: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/, //name选择符处理
        attr: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
        tagName: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/, child: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/, //标签选择符处理
        pos: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/, //子元素选择器
        pseudo: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/


        /**
* 获取元素的位置大小
*
* @param  {element} el 元素
* @return  {object} 返回元素的位置  函数内有详细的注释
*/
U.UF.EL.getElementInfo = function (el) {
    //    UDOD要获取位置的元素    
    if (el) {
        var i, //用于循环
        _arr, //存放所有数据的集合
        _arrbd, //用于获取元素的border属性
        _arrpd = [], //用于获取元素的padding属性
        _arrwh = [], //储存width、height变量 
        _arroffset = ["Top", "Right", "Bottom", "Left"], //用于连接字符串 获得offset属性
        _elgetbc = el.getBoundingClientRect(), //返回一个矩形对象
        _elxy = U.UF.M.pageXY(el), //获取UDOD的位置
        _elp = U.UF.EL.offsetParent(el); //获取元素offsetParent
        for (i = 0; i < _arroffset.length; i++) {  //筛选 padding 和 border
            _arrpd[i] = U.UF.EL.getStyle(el, "padding" + _arroffset[i]).toInt(); //总元素padding属性为获取元素指定的样式padding加上offset属性的整型
            //_arrwh[i] = (_arrbd = U.UF.EL.getStyle(el, "border" + _arroffset[i] + "Width").toInt()).length ? 0 : _arrbd; 
            if ((_arrbd = U.UF.EL.getStyle(el, "border" + _arroffset[i] + "Width").toInt()).length) {//判断是否拥有元素的指定样式border和width两个属性
                _arrwh[i] = 0; //存储border和width变量的则为0
            } else {
                _arrwh[i] = _arrbd//否则，则获取和元素的padding属性一样的值
            }
        }
        _arr = {
            PD: _arrpd, //元素的padding
            BD: _arrwh, //元素的border
            PXT: (document.documentElement.scrollTop) + _elp.scrollTop, //滚动条top位置
            PXL: (document.documentElement.scrollLeft) + _elp.scrollLeft, //滚动条left位置
            SH: el.scrollHeight,  //包含滚动掉的高度
            SW: el.scrollWidth, //包含滚动条的长度
            SL: el.scrollLeft, //滚动条向左的位置
            ST: el.scrollTop, //滚动条向右的位置
            CH: el.clientHeight, //页面不包含 border padding宽度
            CW: el.clientWidth, //页面不包含 border padding长度
            CT: el.clientTop, //页面margin + top的高度
            CL: el.clientLeft, //页面margin + left的长度
            OH: el.offsetHeight, ///页面包含 border padding宽度
            OW: el.offsetWidth,  //页面包含 border padding长度
            OL: el.offsetLeft, //页面left的长度 
            OT: el.offsetTop, //页面top的高度
            BCRH: _elgetbc.bottom - _elgetbc.top, //元素的显示高度
            BCRW: _elgetbc.right - _elgetbc.left, //元素的显示长度
            BCRT: _elgetbc.top, //元素的显示top
            BCRL: _elgetbc.left, //元素的显示left
            BCRB: _elgetbc.bottom, //元素的显示bottom
            BCRR: _elgetbc.right, //元素的显示right
            TX: _elxy[1], //元素的显示高度
            TY: _elxy[0]//元素的显示高度
        };
        _arr.H = _arr["OH"] - _arr["PD"][1] - _arr["PD"][3] - _arr["BD"][1] - _arr["BD"][3]; //原宽度 不包含所有的border padding margin
        _arr.W = _arr["OW"] - _arr["PD"][0] - _arr["PD"][2] - _arr["BD"][0] - _arr["BD"][2]  //原长度 不包含所有的border padding margin

        //        U.UF.C.AddObj(_arr, {
        //            H: _arr["OH"] - _arr["PD"][1] - _arr["PD"][3] - _arr["BD"][1] - _arr["BD"][3], //原宽度 不包含所有的border padding margin
        //            W: _arr["OW"] - _arr["PD"][0] - _arr["PD"][2] - _arr["BD"][0] - _arr["BD"][2]  //原长度 不包含所有的border padding margin
        //        });
        return _arr;
    }
    return {};
}


///**
//* resize变化处理 包含了resizestart endresize 由于resize会出发多次 所有这里可分为 start 和 end
//*
//* @param  {object} resize对象
//*/
//U.UF.EV.resize = function (obj) {
//    var _obj = new U.UF.EV.resize.init(obj); //初始化监视
//    return U.UF.C.apply(_obj, _obj.exec); //设置执行的方式
//}

///**
//* resize方法函数
//*
//* @param  {object} resize对象
//*/
//U.UF.EV.resize.init = function (obj) {
//    U.UF.C.AddObj(this, this.u = obj); //添加事件监视
//}

///**
//* resize方法
//*
//*/
//U.UF.EV.resize.init.prototype = {
//    exec: function () { //执行resize处理
//        this.start(); //onresize回调处理
//        (this.ti) && (clearTimeout(this.ti)); //取消end监视
//        this.ti = setTimeout(function () { this.end(); }, 0); //end处理 
//        (U.UF.C.isFunction(this.u)) && (this.u()); //end事件等待
//    },
//    start: function () {
//        this.iss = true; //设置已经start
//        (!this.iss && this.s) && (this.s()); //函数回调
//    },
//    end: function () {
//        this.iss = false; //end结束
//        (this.e) && (this.e()); //resizeend处理
//    }
//}


        var i, j, k, _UNE, _UTP, _UVE, _UAE, _UST, _UTE = this, i = item || 0, _UL = item + 1 || this.length, _UGE = { "class": "className", "html": "innerHTML", "text": "innerText", "float": "cssFloat" }, _UME = ["width,height,top,bottom,left,right", "px"];
        for (; (i < _UL && i < this.length); i++) {
            for (j in UDE) {
                if (UDE.hasOwnProperty(j)) {
                    if (j == "style") { //style赋值
                        _UVE = ""; _UAE = UDE[j];
                        for (k in _UAE) { //添加cssText
                            if (_UAE.hasOwnProperty(k)) {
                                _UTP = U.UF.EL.styleConversion(k, true); _UNE = _UAE[k];
                                if ((k in this[i][j]) && (_UTP == "css-text" || _UAE[k]) && this[i].cloneNode) {
                                    if (_UTP == "css-text") { _UVE = _UAE[k] + ";" + _UVE; } //cssText赋值
                                    else { (_UME[0].split(",").indexOf(_UTP, null, true) > -1 && U.UF.C.isStringInt(_UNE)) && (_UNE += _UME[1]); _UVE += _UTP + ":" + _UNE + ";"; } //单个属性赋值
                                    continue;
                                }
                                this[i][j][U.UF.EL.styleConversion(k)] = _UAE[k] || "";
                            }
                        }
                        (_UVE != null) && (this[i][j]["cssText"] += ";" + _UVE);  //添加css值
                    }
                    else { //其它属性赋值
                        if (j.indexOf("on") == 0 && "array,string".indexOf(U.UF.C.getType((_UVE = UDE[j]))) > -1) {
                            ((_UVE = UDE[j]) && typeof _UVE[0] == "function") && (_UVE = [_UVE]);
                            UDE[j] = U.UF.C.apply(this[i], _UVE);
                        } //事件特殊处理
                        if (typeof (_UAE = this[i])[j] == "object" && typeof UDE[j] == "object") { U.UF.C.AddObj(_UAE[j], UDE[j]); } //object赋值
                        else { if (_UAE[j] !== UDE[j]) { _UST = _UAE[j]; k = _UGE[j] || j; if (U.UF.C.isString((_UVE = UDE[j])) && U.UF.EL.isCustomAttributes(_UAE, k)) { try { _UAE.setAttribute(k, _UVE); } catch (e) { } } _UAE[k] = UDE[j]; } } //非原属性下的
                    }
                }
            }
        }


        
/**
* 获取大小位置
*
* @param  {element} 元素
* @return  {object} 获取元素的大小 
*/
U.UF.EL.getElementInfo = function (el) {
    var i, _UST, //i用于循环 _UST用于存放width和height
    _UDTD = U.selectEl(el), //获取当前元素
    _UPE = [], //用于存放padding的大小
    _UBE = [], //用于存放border的大小
    _UAE = ["Top", "Right", "Bottom", "Left"]; //用于存放top、left、right、bottom的属性
    //获取padding border
    for (i = 0; i < _UAE.length; i++) {//循环四周有没有padding和border的top、left、right、bottom属性
        _UPE[i] = _UDTD.css("padding" + _UAE[i]).toInt(); //把当前元素获取到的padding属性的大小存放在数组中
        _UBE[i] = _UDTD.css("border" + _UAE[i] + "Width").toInt(); //把当前元素的border属性的大小存放在数组中
        (_UBE[i].length) && (_UBE[i] = 0); //border的长度并且border的长度不为0
    }
    //获取长宽
    _UAE = ["width", "height"]; //用于存放width、height的属性
    for (i = 0; i < _UAE.length; i++) {//循环width和height
        _UST = _UAE[i]; _UAE[i] = _UDTD[_UST]();
    }
    //返回大小处理
    return {
        "PD": _UPE, //padding 
        "BD": _UBE, //border
        "OW": _UAE[0] + _UPE[1] + _UPE[3] + _UBE[1] + _UBE[3], //包含padding border 的长
        "OH": _UAE[1] + _UPE[0] + _UPE[2] + _UBE[0] + _UBE[2], //包含padding border 宽
        "CW": _UAE[0], //不包含padding border 宽
        "CH": _UAE[1]//不包含padding border 宽
    };
}




//,
//    animate: function (UDE, USP, cb, UIF, UGE) { //css3动画效果和js原始动画 动画排队
//        if (UDE) {
//            var i, j, k, _UTE, _UKW, _USE, _UE, _UDID, _UTID, _UME,
//                    _UL = UIF + 1 || this.length,
//                    _UDSD = $$("div").style,
//                    _UAE = [{ "style": {} }, "", {}],
//                    _UCE = ["width", "height", "top", "bottom", "left", "right"],
//                    _UBE = U.UF.CI.getBrowser(), _UTF = _UBE.browser == "msie" && parseInt(_UBE["ver"]), _USD = { "fast": 300, "normal": 1000, "slow": 3000}[USP], _UAF = UDE["IES"]; delete UDE["IES"]; _USD = _USD || USP || 1000;
//            for (i in UDE) { if (UDE.hasOwnProperty(i)) { if (_UDSD[(_UKW = U.UF.EL.styleConversion(i))] === undefined) { _UAE[0][i] = UDE[i]; } else { _UAE[0]["style"][_UKW] = UDE[i]; if (_UKW == "cssText") { _UAE[1] += UDE[i] + ";"; } else { _UAE[1] += (_UKW = U.UF.EL.styleConversion(i, true)) + ":" + UDE[i] + ";"; for (j = 0; j < _UCE.length; j++) { if (_UCE[j] == i || _UKW.indexOf(_UCE[j]) > -1) { _UAE[2][_UKW] = ""; break; } } } } } } //设置css3动画和js动画
//            for (i = (UIF || 0); i < _UL; i++) { _USE = ""; for (j in _UAE[2]) { if (UDE.hasOwnProperty(j)) { j += j.indexOf("padding") > -1 ? "-width" : ""; _UE = this.css(j, null, i); _UE = isNaN(_UE.toInt()) ? ((this[j] ? this[j](i) : 0) + "px") : _UE; _USE += j + ":" + _UE + ";"; } }; (_USE) && (this.addAttrArray({ "style": { "cssText": _USE} }, i)); } //设置初始值
//            if (_UTF && _UTF < 10 && _UAF == null) { this.addAttrArray(_UAE[0], UIF); (U.UF.C.isFunction(cb)) && (cb()); } //Ie8不动画 (cb) && (setTimeout(cb, 0)); 
//            else { //IE9以上动画渲染
//                if (((!_UTF || _UTF > 9) && (_UAE[1] || _UAE[0].className))) { //css3动画加速
//                    _USE = U.UF.EL.GCssAe();
//                    _UDID = "UEM" + Guid.guidNoDash();
//                    _UE = _USE[0] + ":all " + (_USD / 1000) + "s linear;";
//                    if (UGE) {
//                        for (i in UGE) { _UE += _USE[0] + "-" + i + ":" + UGE[i] + ";"; }
//                    }
//                    _UE = "." + _UDID + " {" + _UE + "}"; //设置动画属性
//                    this.bind(_USE[1], (_UTE = U.UF.C.apply(this, function () {
//                        this.unbind(_USE[1], _UTE);
//                        U.UF.EL.AsynCssEM.apply(this, [_UDID, _UDSD, cb, UIF]);
//                    }))); //添加动画
//                    _UDSD = U.UF.DL.LoadStyle(_UE);
//                    U.select.IsAnimate(this, UIF, _UDID);
//                    this.addClass(_UDID, UIF);
//                    (_UAE[0].className) && (this.addClass(_UAE[0].className, UIF), delete _UAE[0].className);
//                    this.addAttrArray(_UAE[0], UIF); delete _UAE[0].className; delete _UAE[0].style; //移除设置回调
//                }
//                for (i in _UAE[0]) {
//                    if (_UAE[0].hasOwnProperty(i)) { //非css动画或者IE8动画
//                        _UME = U.UF.C.Animation({ "cb": function () { this.Auxiliary.animate([UIF, _UL, _UTID, _USE ? null : cb], _UAE[0]); }, "ti": _USD }); //动画加速
//                        U.select.IsAnimate(this, UIF, _UME);
//                        break;
//                    }
//                }
//            }
//        }
//        return this;
//    },
//    stop: function (item) { //停止动画回播
//        var _USE, i = item || 0,
//         _UL = item == null ? this.length : item + 1;
//        for (; i < _UL; i++) {
//            if ((_USE = this[i].__Animate__)) {
//                if (U.UF.C.isString(_USE[2])) {
//                    this[i].className = _USE[2];
//                    this.addClass(_USE[1], i);
//                    this.css("cssText", _USE[0], i);
//                }
//                else {
//                    _USE[2].stop();
//                }
//            }
//        }
//    },
//    opacity: function (UVE, item) { //设置透明度 全兼容
//        if (this.length) {
//            var i, _USE = {}, _UDE = { opacity: 1, "-webkit-opacity": 1, "-moz-opacity": 1, "-khtml-opacity": "", filter: "" };
//            for (i in _UDE) { if (i in this[0].style) { _USE[i] = (_UDE[i] = i == "filter" ? "alpha(opacity=" + (UVE * 100) + ")" : UVE); } }
//        }
//    },
//    fadeIn: function (USP, cb, item) {//动画淡出,,
//        var i, _UKE, _USE = {}, _UDOD = $$("div").style, _UDE = ["opacity", "-webkit-opacity", "-moz-opacity", "-khtml-opacity", "filter"]; cb = U.UF.C.apply(this, function () {
//            this.addAttrArray({ "style": (_UKE = { "display": "none" }) }, item);
//            cb();
//        }); //设置回调 
//        for (i = 0; i < _UDE.length; i++) { if (_UDE[i] in _UDOD) { _UKE[_UDE[i]] = ""; _USE[_UDE[i]] = _UDE[i] == "filter" ? "alpha(opacity=0)" : "0"; break; } }; return this.animate(_USE, USP || "fast", cb, item); //查看
//    },
//    fadeOut: function (USP, cb, item) {//动画淡入
//        var i, _USE = {}, _UDOD = $$("div").style, _UDE = ["opacity", "-webkit-opacity", "-moz-opacity", "-khtml-opacity", "filter"]; for (i = 0; i < _UDE.length; i++) { if (_UDE[i] in _UDOD) { _USE[_UDE[i]] = _UDE[i] == "filter" ? "alpha(opacity=100)" : "1"; _UDE = _UDE[i]; break; } };
//        _USE[_UDE] = _UDE == "filter" ? "alpha(opacity=100)" : "1"; this.addAttrArray({ "style": { "display": "block"} }); return this.animate(_USE, USP || "fast", cb, item); //查看 _USE
//    },
//    slideUp: function (USP, cb, item) { //滑动消失
//        this.slideToggle(USP, cb, item);
//    },
//    slideDown: function (USP, cb, item) { //滑动出现
//        this.slideToggle(USP, cb, item, false);
//    }

//    on: function (UE, US, cb, item) { //事件绑定
//        var _UDE = this; (US) && (_UDE = this.find(US, item)); _UDE.bind(UE, cb, item);
//    },
//    off: function (UE, US, cb, item) { //取消事件绑定
//        var _UDE = this; (US) && (_UDE = this.find(US, item)); _UDE.unbind(UE, cb, item);
//    }

//    resize: function (cb, item) { //resize事件
//        this.bind("resize", U.UF.EV.resize(cb), item);
//    },

//    resizestart: function (cb, item) { //resoze开始
//        this.resize({ s: cb }, item);
//    },
//    resizeend: function (cb, item) { //设置sizeend
//        this.resize({ e: cb }, item);
//    },

//#region 扩展选择器

//U.select.fn.extend({

//});

//    scrollTo: function (UT, UTI) {//移动变化
//        var _UDOD = this[0]; (_UDOD) && (U.UF.EV.scrollToPosition(UT, _UDOD, UTI));
//    }

////#region 事件监听区域

//U.select.fn.extend({
//    cache: [], //保存对象使用选择器保留值
//    cacheE: function (UDOD) {//保存对象的值
//        var i, _UDE = U.select.fn.cache;
//        for (i = 0; i < _UDE.length; i++) { if (_UDE[i].UDOD === UDOD) { return _UDE[i]; } } //获取制定的元素绑定
//        this.events = {}; this.UDOD = UDOD; this.id = Guid.guidNoDash(); _UDE.push(this); return this; //添加事件监听对象
//    }
//});

//U.select.fn.cacheE.prototype = {
//    removeEvent: function (UDE, UAE) { //删除event
//        var i, j, _UME, _UDOD = this.UDOD, _UCE = this.events; (typeof UDE == "string") && (_UME = UDE, (UDE = {})[_UME] = UAE); UDE = UDE || _UCE;
//        for (i in UDE) { if (UDE.hasOwnProperty(i) && (_UME = _UCE[i])) { for (j = 0; j < _UME.length; j++) { if (_UME[j] == UDE[i] || _UCE == UDE || !UDE[i]) { U.UF.EV.delElementEvent(i, _UDOD, _UME.splice(j, 1)[0]); j--; } } } } //清除事件
//    },
//    addevent: function (UDE, UAE) { //添加event监听
//        var i, _UCE = this.events;
//        (!_UCE[UDE]) && (_UCE[UDE] = []); _UCE[UDE].push(UAE);
//    }
//}

////#endregion

////window.$$.NS = function (UNE, UDE, UPE, UCE, UUE) { //创建带有命名空间的元素
////    var _UDOD = U.selectEl(document.createElementNS(UUE || "http://www.w3.org/2000/svg", UNE));
////    _UDOD.addAttrArray(UDE); (UPE) && (_UDOD.appendTo(UPE, 0, UCE)); return _UDOD[0]; //添加属性
////}

////#region 辅助函数

////U.select.fn.extend({
////    selecte: {
////        "only-child": function (UDE) { //获取作为单一孩子节点元素
////            return Array.prototype.slice.call(U.select(UDE).only());
////        },
////        "nth-child": function (UDE, UTP) { //获取第几个元素
////            var i, j, _UCE, _UN = UTP.match(this.match.number)[1], _UTF = _UN.indexOf("n") > -1, _UAE = []; _UN = _UN.toInt();
////            if (!_UTF || _UN) {
////                for (i = 0; i < UDE.length; i++) {
////                    _UCE = U.select(UDE[i]).parentElement().Child();
////                    if (_UTF) { for (j = _UN; j <= _UCE.length; j += _UN) { if (UDE[i] == _UCE[j - 1]) { _UAE.push(UDE[i]); (_UN == 1) && (j++); break; } } } //(xn)查找
////                    else { (_UCE[_UN - 1] == UDE[i]) && (_UAE.push(UDE[i])); } //直接获取第几个
////                }
////            }
////            return _UAE;
////        },
////        "first-child": function (UDE) { //获取开头元素
////            var i, _UAE = [];
////            for (i = 0; i < UDE.length; i++) { (!U.select(UDE[i]).prev().lenght) && (_UAE.push(UDE[i])); }
////            return _UAE;
////        },
////        "last-child": function (UDE) { //获取末尾元素
////            var i, _UAE = [];
////            for (i = 0; i < UDE.length; i++) { (!U.select(UDE[i]).next().length) && (_UAE.push(UDE[i])); }
////            return _UAE;
////        },
////        first: function (UDE) { //获取第一个匹配的元素
////            return UDE.length ? UDE[0] : UDE;
////        },
////        last: function (UDE) { //获取最后一个匹配元素
////            return UDE.length ? UDE[UDE.length - 1] : UDE;
////        },
////        nth: function (UDE, UTP) { //获取匹配的第几个元素
////            var i, _UAE = [], _UN = UTP.match(this.match.number)[1], _UTF = _UN.indexOf("n") > -1; _UN = _UN.toInt();
////            if (_UTF || _UN) {
////                if (_UTF) { for (i = _UN; i <= UDE.length; i += _UN) { _UAE.push(UDE[i - 1]); } }
////                else { (UDE[_UN]) && (_UAE.push(UDE[_UN])); }
////            }
////            return _UAE;
////        },
////        getevenodd: function (UDE, UTP) { //获取奇数和偶数集
////            var i, j, _UDPD, _UCE, _UTF, _UPE = [], _UAE = [];
////            for (i = 0; i < UDE.length; i++) {
////                _UCE = null; _UDPD = UDE[i].parentNode;
////                for (j = 0; j < _UPE.length; j++) { if (_UPE[j][0] == _UDPD) { _UCE = _UPE[j]; _UCE[1].push(UDE[i]); } }
////                (!_UCE) && (_UPE.push((_UCE = [_UDPD, [UDE[i]]]))); _UTF = (_UCE[1].length - 1) % 2; ((UTP == "even" && !_UTF) || (UTP == "odd" && _UTF)) && (_UAE.push(UDE[i]));
////            }
////            return _UAE;
////        },
////        even: function (UDE) { //获取偶数集
////            return this.selecte.getevenodd(UDE, "even");
////        },
////        odd: function (UDE) { //获取奇数集
////            return this.selecte.getevenodd(UDE, "odd");
////        },
////        eq: function (UDE, UTP) { //获取制定的位置列
////            return UDE[UTP.match(this.match.number)[1].toInt()];
////        },
////        gt: function (UDE, UTP) { //索引大于的元素
////            U.select(UDE).gt(UTP.match(this.match.number)[1].toInt());
////        },
////        lt: function (UDE, UTP) {//索引小于的元素
////            U.select(UDE).lt(UTP.match(this.match.number)[1].toInt());
////        },
////        "first-of-type": function () { },
////        "last-of-type": function () { },
////        "only-of-type": function () { },
////        "nth-last-child": function () { },
////        "nth-of-type": function () { },
////        "nth-last-of-type": function () { }
////    }
////});

////简单的复杂的方法统一
////$.SetMethod.prototype = U.select.prototype;

////#endregion

////#endregion


//,
//    length: 0, //初始化长度
//    splice: Array.prototype.splice,
//    constructor: Array

//U.select.fn.init.prototype = U.select.fn; //添加扩展



//        el = el || document;
//        //如果是字符串说明用户要通过选择器找到字符串
//        if (U.UF.C.isString(name)) {
//            var i, j, k, _UTP, _UIE, _UTF, _UVE, _UGE, _UXE, _UJE, _UOT, _UST = "",
//                _UDE = el,
//                _UME = this.match, //获取选取的正则
//                _UCE = name.replace(_UME.escape, U.select.GetSelector),
//                _UCN = _UME.con,
//                _UKE = [],
//                _UBE = U.UF.CI.getBrowser(); //浏览器版本
//            _UBE = (_UBE.browser == "msie" && _UBE.ver.toInt()); //ie的版本

//            //拆分选择器
//            do {
//                _UCN.exec("");
//                _UCE = _UCN.exec(_UCE);
//                _UKE.push(_UCE[1] + (_UCE[2] || ""));
//                _UCE = _UCE[3];
//            }
//            while (_UCE); //生成获取集合
//            _UXE: for (i = 0; (i < _UKE.length && _UDE); i++) {
//                if (_UBE < 6 && _UME.nregular.test((_UTF = _UKE[i + 1]))) {//处理选择伪类等
//                    if (_UTF == "+" || _UTF == "~") { //向下选择
//                        if (_UOT = (_UME.pos.test(_UKE[i]) || _UME.child.test(_UKE[i]))) {
//                            _UVE = this.getelement(_UKE[i], _UDE, _UST);
//                            (U.UF.Ut.isHtmlElement(_UVE)) && (_UVE = [_UVE]);
//                        }
//                        else {
//                            _UJE = this.getType(_UKE[i]);
//                        }
//                        _UIE = this.getType(_UKE[i + 2]);
//                        _UDE = this.gete(_UDE, _UIE[4], _UST, _UIE);
//                        for (j = 0; j < _UDE.length; j++) { //判断获取
//                            _UTP = false;
//                            this.celement.apply[_UDE[j]], [_UTF == "+" ? "previousSibling" : "prevaAll", NaN, _UGE = []]; //获取
//                            for (k = 0; k < _UGE.length; k++) {
//                                if (_UOT) {
//                                    if (_UVE.indexOf(_UGE[k]) > -1) { _UTP = true; break; }
//                                } else if (_UGE[0][_UJE[3]].toLowerCase() == _UKE[i]) { _UTP = true; break; }
//                            }
//                            (!_UTP) && (_UDE.splice(j, 1), j--);
//                        }
//                    }
//                    else if (_UTF == ">") { //子元素
//                        _UVE = this.getelement(_UKE[i], _UDE, _UST);
//                        if (typeof _UVE == "string") {
//                            _UVE == this.gete(_UDE, "", _UST);
//                        }
//                        if ((_UDE = _UVE)) {
//                            (U.UF.Ut.isHtmlElement(_UDE)) && (_UDE = [_UDE]);
//                            _UGE = [];
//                            _UIE = this.getType(_UKE[i + 2]);
//                            _UVE = this.gete(_UDE, _UIE[4], "", _UIE);
//                            for (j = 0; j < _UVE.length; j++) {
//                                for (k = 0; k < _UDE.length; k++) {
//                                    if (_UDE[k] == _UVE[j].parentNode) {
//                                        _UGE.push(_UVE[j]); break;
//                                    }
//                                }
//                            }; _UDE = _UGE;
//                        }
//                    }
//                    _UST = ""; i += 2;
//                    (_UIE[2]) && (_UDE = this.getelement("", _UDE, _UIE[2]));
//                }
//                else {
//                    if (_UKE[i].length > 1 && _UKE[i].indexOf("*") > -1) {
//                        _UKE[i] = _UKE[i].substr(1);
//                        if (!(_UDE = document[_UKE[i]])) {
//                            if (U.UF.CI.getBrowser().browser == "msie") {
//                                _UDE = document.getElementById(_UKE[i]);
//                            } else { _UDE = document.embeds[_UKE[i]]; }
//                        } _UST = "";
//                    }
//                    else {
//                        _UVE = this.getelement(_UKE[i], _UDE, _UST);
//                        if (typeof _UVE == "string") { _UST += _UVE; }
//                        else if (_UVE) { _UDE = _UVE; _UST = ""; }
//                        else if (_UVE === null) { _UDE = null; break _UXE; }
//                        else { _UST += _UKE[i]; }
//                    }
//                }
//            }
//            if (_UST && _UDE) {
//                _UIE = this.getType(_UST);
//                _UTF = (_UIE && !_UIE[2].trim());
//                _UDE = this.gete(_UDE, _UIE ? _UIE[4] : "", _UTF ? "" : _UST, _UTF ? _UIE : null);
//            } //添加元素
//        }
//        else {
//            var _UDE = name || [];
//        }
//        if (_UDE) {
//            this.osadd(_UDE);
//        }
//    //多个选择
//    osel: function (UTP, UTV, UDE, UTE) {
//        var i, j, _UKE, _UAE = [], _UCE = [], _UTP = "parentNode", _UTF = true;
//        if (UTP) { //选择
//            _UCE = [];
//            for (i = 0; i < UDE.length; i++) {
//                if (UDE[i][UTP] == UTV || UDE[i].getAttribute(UTP) == UTV || UTV === undefined) {
//                    _UCE.push(UDE[i]);
//                }
//            }
//        }
//        else {
//            for (i = 0; i < UDE.length; i++) {
//                for (j = 0; j < _UAE.length; j++) {
//                    if (UDE[i][_UTP] == _UAE[j][0]) {
//                        _UAE[j][1].push(UDE[i]); break;
//                    }
//                    _UAE.push[UDE[i][_UTP], [UDE[i]]];
//                }
//            } //选择的元素
//            for (i = 0; i < _UAE.length; i++) { //选择
//                _UKE = (UTE && _UAE[0][UTE]) ? _UAE[0][UTE](UTP) : SelectorElement(UTP, _UAE[0]); //获取
//                for (j = 0; j < _UKE.length; j++) {
//                    if (!_UAE[1].length) { break; }
//                    ((i = _UAE[1].indexOf(_UKE[j])) > -1) && (_UCE.push(_UKE[j]), _UAE[1].splice(i, 1));
//                }
//            }
//        }
//        return _UCE;
//    },

//    //添加选择的元素
//    osadd: function (UDE) {

//        if (U.UF.Ut.isHtmlElement(UDE) || UDE.length == null) {
//            UDE = [UDE];
//        }

//        for (var i = 0; i < UDE.length; i++) {
//            if (UDE[i]) {
//                this[this.length++] = UDE[i];
//                (UDE[i].id) && (this[UDE[i].id] = UDE[i]);
//            }
//        }
//        return this; //添加元素
//    },

//    //移除元素
//    del: function (item, UTF) {
//        var i, _UL = this.length; (item != null) && (this[item] = null);
//        if (!UTF) {
//            for (i = 0; i < _UL; i++) {
//                if (this[i] == null) {
//                    if (this[i + 1]) {
//                        this[i] = this[i + 1];
//                        this[i + 1] = null;
//                    }
//                    else { delete this[i]; } this.length--;
//                }
//            }
//        }
//    },
//    gete: function (UDE, UTP, UTS, USM) {//获取元素
//        var i, _UCE, _UKE = []; (U.UF.Ut.isHtmlElement(UDE)) && (UDE = [UDE]);
//        for (i = 0; i < UDE.length; i++) {
//            _UCE = UDE[i]; _UCE = (!UTS && (USM[1].length >= USM[0].length - 1) && _UCE[UTP]) ? _UCE[UTP](USM[1]) : SelectorElement(UTS + (USM ? USM[0] : ""), _UCE);
//            if (_UCE) { (U.UF.Ut.isHtmlElement(_UCE)) && (_UCE = [_UCE]); _UKE = _UKE.concat(U.UF.C.toArray(_UCE)); }
//        }
//        return _UKE;
//    },
//    getelement: function (UCE, UDE, USE) {//通过选择字符串获取元素
//        var i, _UME = this.match, _UAE = UCE ? this.getType(UCE) : "", _UST = _UAE && _UAE[2], _UBE = U.UF.CI.getBrowser(), _UTF = _UME.pos.test(_UST) || _UME.child.test(_UST); _UBE = (_UBE.browser == "msie", _UBE.ver.toInt()); if (!_UAE && UCE) { return _UAE; }
//        if (_UAE && USE !== true && (_UAE[0] == UCE || _UAE[2].indexOf(":") == -1) || (!_UTF || (!_UBE || _UBE > 8 || (UCE.indexOf("first-child") > -1 && _UBE > 6)))) { return UCE + " "; } //兼容添加选择值
//        else {
//            if (_UTF) { //过滤选择 //伪类选择
//                _UST = _UST.split(":"); _UAE[0] += _UST[0]; UDE = this.gete(UDE, _UAE[4], USE, _UAE);
//                for (i = 1; i < _UST.length; i++) { if (_UST[i] && !U.UF.Ut.isHtmlElement(UDE)) { UDE = this.selecte[_UST[i].split("(")[0]].call(this, UDE, _UST[i]); } }
//            }
//            else { UDE = this.gete(UDE, _UAE[4], "", _UAE); }; return UDE
//        }
//    },
//    getType: function (UCE) {//获取格式
//        var i, _UJE, _UME = this.match, _UAE = { "name": "getElementsByName", "id": "getElementById", "tagName": "getElementsByTagName", "className": "getElementsByClassName" };
//        for (i in _UAE) { if ((_UJE = _UME[i].exec(UCE))) { return [_UJE[0], _UJE[1], UCE.replace(_UJE[0], ""), i, _UAE[i]]; } } //获取值
//    },
//    getValue: function (USE) { //通过选择字符串生成响应的选择
//        var i, _UDE = {}, _UNC = this.common.nregular, _UC = this.common.regular, _UNCA = (USE.match(_UNC) || []), _UCA = USE.match(_UC) || ["*"];
//        for (i = 0; i < _UCA.length; i++) { switch (_UNCA[j]) { case "!": _UDE["name"] = _UCA[j]; break; case "#": _UDE["id"] = _UCA[j]; break; case ".": _UDE["className"] = _UCA[j]; break; case "": case "&": _UDE["tagName"] = _UCA[j]; break; } } //获取
//        return _UDE;
//    },


///**
//* 动画处理使用
//*
//* @param   {string} 选择特殊字符串 包含# & []
//* @param   {document} 搜索的层次
//* @param   {document} 搜索的层次
//*/
//U.select.IsAnimate = function (UDE, item, UCL) {
//    var i = item || 0, _UL = item == null ? UDE.length : item + 1, _UTF = arguments.length > 0;
//    for (; i < _UL; i++) {
//        if (_UTF) {
//            UDE[i].__Animate__ = [UDE[i].style.cssText, UDE[i].className, UCL];
//        }
//        else {
//            UDE[i].__Animate__ = null; delete UDE[i].__Animate__;
//        }
//    }
//};



////通过元素的来获取 
///**
//* 使用正则表带是
//*
//* @param   {string} 选择 
//* @param   {document} 搜索的层次
//*/
//$.getElementByString = function (name, el) {
//    var _e, //这个是获取成功的函数
//        _r = name.substring(0, 1), //获取特殊字符 . # 或者 ""
//        _n = name.substring(1, name.length), //获取标签名
//        _doc = el || document; //去除特殊字符后

//    //这里是判断获取
//    try { //这里利用基础的选择器选取数据 
//        switch (_r) {
//            case "#": //根据id获取 因为id获取只能通过全局搜索 但是由于项目中有存在克隆的情况 会出现id不唯一的情况
//                if (_doc == document && U.UF.S.EN.test(_n)) {
//                    _e = document.getElementById(_n);
//                }
//                break;
//            case ".": //根据className获取
//                if (U.UF.S.EN.test(_n)) {
//                    _e = _doc.getElementsByClassName(_n);
//                }
//                break;
//            case "*": //根据className获取
//                if (U.UF.S.EN.test(_n)) {
//                    _e = _doc.getElementsByTagName("*");
//                }
//                else {
//                    _e = document[_n];
//                    if (U.UF.CI.getBrowser().browser == "msie") {
//                        _e = document.getElementById(_n);
//                    }
//                    else {
//                        _e = document.embeds[_n];
//                    }
//                }
//                break;
//            default: //标签的获取 //获取指定的元素
//                if (U.UF.S.EN.test(name)) {
//                    _e = _doc.getElementsByTagName(name); //除去特殊字符的处理
//                }
//                break;
//        }
//    }
//    catch (e) { }
//    //判断是否获取元素成功，如果上面简单的选择去不成功，那么就通过其他的选择器方案去获取
//    if (_e == null) {
//        _e = U.UF.CP.SelectorElement(name, _doc); //其他选择的方式获取
//    }
//    return new $.SetMethod(_e); //把选择的元素添加方法
//}

///**
//* 元素方法
//*
//* @param   {object} 设置的域
//*/
//$.SetMethod = function (el) {
//    el = el || [];
//    //把所有获取出来的元素转化成数组，以便下面循环添加
//    if (U.UF.Ut.isHtmlElement(el) || el.length == null) {
//        el = [el];
//    }
//    //设置获取元素的长度
//    this.length = el.length;
//    //循环所有的元素，把元素设置到this里面，这样用户获取到的元素集就能通过this[0]或者this[id]去获取了
//    for (var i = 0; i < el.length; i++) {
//        //如果元素存在的处理
//        this[i] = el[i];
//        //如果元素有id，那么给返回值添加一个id的处理，以便返回值中有以id作为key的返回值
//        if (el[i].id) {
//            this[el[i].id] = el[i];
//        }
//    }
//}


///**
//* 初始化编辑区域
//*
//* @param   {string} 选择特殊字符串 包含# & []
//* @param   {document} 搜索的层次
//*/
//U.select.GetSelector = function (UST) { //处理选择器
//    if (UST == "#") { //getElementById 的选择符
//        return " #";
//    }
//    else if (UST == "&") { //className联合的选择符
//        return " ";
//    }
//    else if (UST.charAt(0) == "!") { //自定义参数的选择符
//        return "[name='" + UST.substr(1) + "']";
//    }
//    else { //自定义参数使用
//        return "[" + UST.substr(1).replace(U.select.prototype.match.ename, "='$1'") + "]";
//    }
//};

//    //正则匹配选择器
//    match: {
//        ename: /=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*/g, //[]选择符的使用
//        escape: /(&|![\w\u00c0-\uFFFF\-]|\@[\w\u00c0-\uFFFF\-]+=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*)/g, //需要转义的正则
//        nregular: /[>|+|~]/g, //伪类选择
//        con: /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, //通用符的使用
//        className: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,  //className的定义
//        id: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, //id的定义
//        name: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/, //name选择符处理
//        attr: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
//        tagName: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/, child: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/, //标签选择符处理
//        pos: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/ //子元素选择器
//    },





///**
//* 初始化对话框实例
//* @returns {function} 回调函数初始化
//* @arguments 对象的 length 属性包含了传递给U.UF.UI.Dialog的参数的数目。
//*/
//U.UF.UI.Confirm.init = function (UDE) {
//    var i, _UCE = ["title", "style", "confirmNoClose", "confirmYesClose", "content", "top"];
//    if (UDE.length < 4) {
//        var _UDOD = U.selectEl("#U_COF"); //创建一个ID为U_COF的对象
//        UDE = ["消息提示", { "width": "300px" }, UDE[2], UDE[1],
//              $$("div", {
//                  "className": "U_UI_OC",
//                  "style": {
//                      "textAlign": "center",
//                      "margin": "25px 0",
//                      "max-width": "400px",
//                      "word-wrap": "break-word",
//                      "max-height": "400px",
//                      "overflow": "auto"
//                  },
//                  innerHTML: UDE[0] ? UDE[0] : ""
//              })];
//    }
//    for (i = 0; i < UDE.length; i++) {
//        this[_UCE[i]] = UDE[i];
//    }
//    this.Create();
//}

//U.UF.UI.Confirm.init.prototype = {
//    /**
//    * 创建对话框的ui
//    */
//    Create: function () {
//        var i, _UDE, _UDOD, _UDTD, _UDID, _UDSD, _UCB, _USE = {
//            width: "auto",
//            height: "auto"
//        },
//       _UEK = (this.style = this.style || {});
//        _USE.forEach(function (UA, UB) {
//            _UEK[UB] = _UEK[UB] || UA;
//        });
//        _UEK.zIndex = 9999;

//        var _frag = $$("frag");

//        _UDOD = $$("div",
//        {
//            "className": "U_UI_OB"
//        });
//        _UDTD = $$("div",
//    {
//        "className": "U_UI_OBA"
//    }, _UDOD);
//        this.No = $$("div", {
//            "onclick": function () {
//                this.confirmYesNo(this.confirmNoClose);
//            },  // [(Array.isArray(this.confirmNoClose) ? this.confirmNoClose : [this.confirmNoClose]), [(_UCB = U.UF.C.apply(_UDE, [[_UDE.shut]]))]],
//            "innerHTML": "取消",
//            "style": { "display": this.Q == true ? "none" : "block" },
//            "className": "U_UI_OBY"
//        }, _UDTD);

//        this.Yes = _UDSD = $$("div", {
//            "onclick": function () {
//                this.confirmYesNo(this.confirmYesClose);
//            }, //[(Array.isArray(this.confirmYesClose) ? this.confirmYesClose : [this.confirmYesClose]), [_UCB]],
//            "innerHTML": "确定",
//            "className": "U_UI_OBY"
//        }, _UDTD); //确定按钮

//        _frag.appendChild(this.content);
//        _frag.appendChild(_UDOD);


//        this.form = _UDE = new U.UF.UI.form({
//            id: "U_COF",
//            top: this.top ? true : false,
//            min: false,
//            max: false,
//            style: this.style,
//            title: "<div class='UD_SYF_STI'>" + (this.title || "对话框") + "</div>",
//            content: _frag,
//            hst: {
//                style: {
//                    padding: "0"
//                }
//            },
//            draw: false
//        }); //创建对话框




//        //    U.selectEl(_UDE.middle).append(_UDOD);

//        _UDID = U.selectEl("input", _UDE.middle);
//        for (i = _UDID.length - 1; i >= 0; i--) {
//            if ("text,password".indexOf(_UDID[i].type) > -1) {
//                _UDID[i].focus();
//                _UDID[i].onkeypress = U.UF.C.apply(_UDID[i], function () {
//                    U.UF.C.returnkeylogin([{
//                        "obj": _UDSD,
//                        "event": 'onclick'
//                    }]);
//                });
//            }
//        }
//        return _UDE;
//    },

//    /**
//    * 给对话框设置事件
//    * @param  {object} 窗体事件使用
//    ----------[yes] {function} 确定的函数事件
//    ----------[no] {function} 取消的函数事件
//    */
//    AddEvent: function (UDE) {
//        for (var i in UDE) {
//            if (UDE.hasOwnProperty(i)) {
//                this[i].onclick = U.UF.C.apply(this.form, function () {
//                    this.form.shut();
//                    UDE[i]();
//                }); //
//            }
//        }
//    },

//    /**
//    * 给对话框设置事件
//    * @param  {object} 窗体事件使用
//    */
//    confirmYesNo: function (fun) {
//        var _UCB = U.UF.C.apply(this.form, this.form.shut), //关闭窗体的函数
//        _UTF = Array.isArray(fun) ? U.UF.C.apply(this, fun)() : (fun) && (fun.call(this));
//        if (_UTF !== false) { //不允许关闭
//            _UCB();
//        }

//        //      [(Array.isArray(this.confirmNoClose) ? this.confirmNoClose : [this.confirmNoClose]), [(_UCB = U.UF.C.apply(_UDE, [[_UDE.shut]]))]]
//    }
//}


/*U.UF.UI.Dialog = function (UDC, UDT, UDID, UDW, UDH) {
(!UDW || !UDH) && (UDW = "400px", UDH = "550px");
return U.UF.UI.form({
id: UDID ? UDID : null,
style: { "width": parseInt(UDW) + "px", "height": parseInt(UDH) + "px" },
content: UDC ? UDC : null, title: UDT ? UDT : "通知",
min: false,
max: false,
draw: false
});
}*/

//U.UF.UI.Confirm = function (UCT, UCBF, UCNF) {
//    var _UDOD = U.selectEl("#U_COF"); //创建一个ID为U_COF的对象
//    if (_UDOD[0]) { //判断是否有U_COF的子节点，没有则创建
//        _UDOD.childs(0, 1).childs(0, 0).html(UCT); //设置内容
//        _UDOD.Center(); //内容居中
//    } else {
//        U.selectEl(U.UF.UI.Dialog("消息提示", {}, UCNF ? U.UF.C.apply(this, [UCNF]) : null, UCBF ? U.UF.C.apply(this, [UCBF]) : null,
//            $$("div", {
//                "className": "U_UI_OC",
//                "style": {
//                    "textAlign": "center",
//                    "padding": "25px 0 25px 0"
//                },
//                innerHTML: UCT
//            })).Create()).addAttrArray({
//                "id": "U_COF"
//            })[0];
//    U.UF.EV.stopBubble(); //阻止冒泡
//    return _UDOD;
//}

/**
* 创建一个通知形式的对话框
*{str} UDC 对话框里面的内容。 
*{str} UDT 标题
*{str} UDID 对话框id
*{int} UDW 宽度
*{int} UDH 高度
* @returns  返回ID为U_COF的对象
**/
//U.UF.UI.Dialog = function (UDC, UDT, UDID, UDW, UDH) {
//    return new U.UF.UI.Dialog.init(arguments);
//}

//U.UF.EV.addPrototype(U.UF.UI.Dialog, U.UF.C.AddObj(U.UF.UI.Dialog, {
//    init: function (UDE) { //添加对话框信息
//        var i, _UCE = ["title", "style", "confirmNoClose", "confirmYesClose", "content", "SO"];
//        for (i = 0; i < UDE.length; i++) {
//            this[_UCE[i]] = UDE[i];
//        }
//    },
//    Create: function () { //创建对话框
//        var i, _UDE, _UDOD, _UDTD, _UDID, _UDSD, _UCB, _USE = {
//            width: "auto",
//            height: "auto",
//            minWidth: "300px"
//        },
//            _UEK = (this.style = this.style || {});
//        _USE.forEach(function (UA, UB) {
//            _UEK[UB] = _UEK[UB] || UA;
//        });
//        _UEK.zIndex = 9999;
//        _UDE = new U.UF.UI.form({
//            top: true,
//            min: false,
//            max: false,
//            style: this.style,
//            title: "<div class='UD_SYF_STI'>" + (this.title || "对话框") + "</div>",
//            content: this.content,
//            hst: {
//                style: {
//                    padding: "0"
//                }
//            }
//        }); //创建对话框
//        _UDOD = $$("div", {
//            "className": "U_UI_OB"
//        });
//        _UDTD = $$("div", {
//            "className": "U_UI_OBA"
//        }, _UDOD);
//        $$("div", {
//            "onclick": [
//                [this.confirmNoClose],
//                [(_UCB = U.UF.C.apply(_UDE, _UDE.close))]
//            ],
//            "innerHTML": "取消",
//            "className": "U_UI_OBY"
//        }, _UDTD);
//        _UDSD = $$("div", {
//            "onclick": [
//                [this.confirmYesClose],
//                [_UCB]
//            ],
//            "innerHTML": "确定",
//            "className": "U_UI_OBY"
//        }, _UDTD); //确定按钮
//        U.selectEl(_UDE.middle).append(_UDOD);
//        _UDID = U.selectEl("input", _UDE.middle);
//        for (i = _UDID.length - 1; i >= 0; i--) {
//            if ("text,password".indexOf(_UDID[i].type) > -1) {
//                _UDID[i].focus();
//                _UDID[i].onkeypress = U.UF.C.apply(_UDID[i], function () {
//                    U.UF.C.returnkeylogin({
//                        "obj": _UDSD,
//                        "event": 'onclick'
//                    });
//                });
//            }
//        }
//    }
//}));



//U.UF.UI.Dialog.init.prototype = U.UF.UI.Dialog.prototype;


///*
//弹出提示框，为了同时弹出多个提示框，为多份实例对象
//1、可以像java语言的用法，用new调用多份，例如： var a=new U.AlertB();
//2、也可以省略new的步骤，直接U.Alert()，出来的结果为多份。
//参数一：UTH 内容
//参数二：UTI 无确认按钮的显示时间
//参数三：是否带确认按钮
//返回值：
//*/
//U.Alert = function (UTH, UTI, IFQ) {
//    IFQ === true ? new U.AlertA(UTH, IFQ) : new U.AlertB(UTH, UTI);
//}

////为了多份实例，另外建立一个类似类的函数。
////带有确定按钮的alert
//U.AlertA = function (UTH) {
//    U.UF.UI.Confirm("提示框", {}, null, null, $$("div", {
//        "style": {
//            "textAlign": "center",
//            "margin": "25px 10px 25px 10px",
//            "max-width": "400px",
//            "word-wrap": "break-word",
//            "max-height": "400px",
//            "overflow": "auto"
//        },
//        innerHTML: UTH
//    }), true);
//}

////自动消失的alert
//U.AlertB = function (UTH, UTI) {
//    this.TI = ((UTI == null || UTI < 0) ? 1000 : UTI);
//    var _UDPD = U.selectEl("body")[0];
//    this.UDOD = U.selectEl($$("div", {
//        "innerHTML": UTH,
//        "className": "USalert",
//        "style": { "cssText": "z-index:9999;left:" + ((US.width / 2 - 160) + _UDPD.scrollLeft) + "px;top:" + ((US.height / 2 - 100) + _UDPD.scrollTop) + "px" },
//        "onclick": function () { this.DAlert(true); }
//    }, U.selectEl("body")[0])).css({
//        "top": US.height / 2 - 80 + _UDPD.scrollTop + "px"
//    });
//}

////为了减少内存消耗，把方法写在原型中。
//U.AlertB.prototype = {
//    //    init: function (UTH, UTI) {//创建alert "id": "USalert",
//    //        this.TI = ((UTI == null || UTI < 0) ? 1000 : UTI); this.UDOD = U.selectEl($$("div", { "innerHTML": UTH, "className": "USalert", "style": { "cssText": "z-index:9999;left:" + (US.width / 2 - 160) + "px;top:" + (US.height / 2 - 100) + "px" }, "onclick": function(){this.DAlert(true);} }, U.selectEl("body")[0])).animate({ "top": US.height / 2 - 80 + "px" }, 300, function(){this.AsynAmAlert();});
//    //    },
//    AsynAmAlert: function () { //等待动画
//        this.UTI = setTimeout(function () { this.AmAlert(); }, this.TI || 1000); //异步等待
//    },
//    AmAlert: function () { //结束动画
//        if (this.UTI) { clearTimeout(this.UTI) };
//        var _UDOD = U.selectEl(this.UDOD);
//        if (_UDOD.Parent() == document.body) {
//            _UDOD.animate({
//                "top": _UDOD[0].offsetTop - 70 + "px"
//            }, 100, function () { this.DAlert(); })
//        };
//    },
//    DAlert: function (UTF) { //移除alert
//        if (this.TI || UTF) {
//            U.selectEl(this.UDOD).remove();
//        }
//    }
//}


//U.UF.EV.addPrototype(U.AlertB, {
//    //    init: function (UTH, UTI) {//创建alert "id": "USalert",
//    //        this.TI = ((UTI == null || UTI < 0) ? 1000 : UTI); this.UDOD = U.selectEl($$("div", { "innerHTML": UTH, "className": "USalert", "style": { "cssText": "z-index:9999;left:" + (US.width / 2 - 160) + "px;top:" + (US.height / 2 - 100) + "px" }, "onclick": function(){this.DAlert(true);} }, U.selectEl("body")[0])).animate({ "top": US.height / 2 - 80 + "px" }, 300, function(){this.AsynAmAlert();});
//    //    },
//    AsynAmAlert: function () {//等待动画
//        this.UTI = setTimeout(function(){this.AmAlert();}, this.TI || 1000); //异步等待
//    },
//    AmAlert: function () {//结束动画
//        (this.UTI) && (clearTimeout(this.UTI)); var _UDOD = U.selectEl(this.UDOD);
//        (_UDOD.Parent() == document.body) && (_UDOD.animate({ "top": US.height / 2 - 70 + "px" }, 100, function(){this.DAlert();}));
//    },
//    DAlert: function (UTF) { //移除alert
//        if (this.TI || UTF) { U.selectEl(this.UDOD).remove(); }
//    }

//}); //U.UF.C.AddObj(U.Alert,})
//U.Alert.prototype.init.prototype = U.Alert.prototype;



////#region 分页控件
//Namespace.register("U.UF.P");

////分页控件设置
///*
//功能：传统分页控件，此函数将预先加载。以后需多做几种样式。
//参数一：UDE代表className为UD_SYFLB的div元素
//参数二：UOD代表聊天条数。
//参数三：UDP为整形1，默认第一页，其他数字，则为相应的显示页。
//参数四: UNP代表一页显示多少条数据
//参数五：USN为打印聊天信息的函数
//*/
//U.UF.P.PPage = function (UOD, USN, UNP, UDN, UCF, UTF) {
//    var i, j, _USE, _UKE,
//            _UME = U.UF.P.PPage.setPage(USN, UNP, UDN, UCF);
//    if (U.UF.C.isFunction(UTF)) {
//        _USE = UTF(this);
//        _UKE = { //按钮对应事件处理
//            "pre": { "onclick": function () {
//                U.UF.P.PPage.exec(UNP - 1, _UBE[1], UOD, USN, UNP, UDN, UCF);
//            }
//            }, //上一页
//            "next": { "onclick": function () {
//                U.UF.P.PPage.exec(UNP + 1, _UBE[2], UOD, USN, UNP, UDN, UCF);
//            }
//            }, //下一页
//            "frit": { "onclick": function () {
//                U.UF.P.PPage.exec(1, _UBE[0], UOD, USN, UNP, UDN, UCF);
//            }
//            }, //第一页
//            "last": { "onclick": function () {
//                U.UF.P.PPage.exec(UNP + 1, _UBE[2], UOD, USN, UNP, UDN, UCF);
//            }
//            }, //最后一页
//            "input": [
//                {
//                    "onkeyup": [U.UF.C.returnkeylogin, [null, function () {
//                        U.UF.P.PPage.PageAchieve(UDE[3], UOD, USN, UNP, UDN, UCF, null, UDP);
//                    } ]],
//                    "onclick": function () {
//                        U.UF.P.PPage.PageAchieve(UDE[3], UOD, USN, UNP, UDN, UCF, null, UDP);
//                    }
//                }

//                     ], //输入框 按钮
//            "page": [] //页码按钮 变化样式 当前页的样式
//        };
//        for (i in _USE) {
//            if (_USE.hasOwnProperty(i) && _UKE[i]) {
//                if (Array.isArray(_UKE[i])) {
//                    for (j = 0; j < _UKE[i].length; j++) {

//                    }
//                }
//                else {
//                    for (j in _UKE[i]) {
//                        _USE[i][j] = _UKE[i][j]
//                    }
//                }
//            }
//        }
//    }
//    else if (!UTF) { //  创建分页控件
//        U.UF.P.PPage.CPage(_UME[0], UOD, _UME[1], UNP, USN, UDN, UCF)
//    }
//    return _UME;
//}

////分页控件显示
//U.UF.P.PPage.CPage = function (UDE, UOD, UDP, UNP, USN, UDN, UCF, UDOD) {
//    var i, _UN, _USP, _UDOD, _UDTD, _UDSD, _UDGD, _UTE, _UAE, _UCE = [], _UBE = [];
//    for (i = 0; i < 4; i++) {
//        switch (i) {
//            case 0:
//                _UTF = UNP != 1;
//                break;
//            case 1:
//                _UTF = UNP > 1;
//                break;
//            case 2:
//                _UTF = UNP < UDP;
//                break;
//            case 3:
//                _UTF = UNP != UDP;
//                break;
//        }
//        if (_UTF) {
//            _UBE[i] = UDE[i == 3 ? i + 1 : i];
//        } else {
//            _UCE[i] = "O";
//        }
//    }
//    if (UDOD) {
//        //分页控件分页
//        _UDTD = U.selectEl(UDOD).Child(),
//                _UDAD = U.selectEl(_UDTD[0]).childs(),
//                _UTE = [1, UNP - 1, UNP + 1, UDP];
//        U.selectEl(_UDTD[1]).Child()[2].innerText = UNP + "页";
//        _UAE = ["O", "T", "S", "F"];
//        //跳页赋值
//        for (i = 0; i < 4; i++) {
//            _UDAD.addAttrArray({
//                "onclick": _UCE[i] ? "" : function () {
//                    U.UF.P.PPage.exec(_UTE[i], _UBE[i], UOD, USN, UNP, UDN, UCF, UDOD);
//                },
//                "className": "U_Boom_Img_ys2017 UD_SYFYL" + _UAE[i] + (_UCE[i] || "")
//            }, (UCF.isp && i > 1) ? i + 1 : i);
//        }
//        //页码赋值
//        if (UCF.isp) {
//            _UDAD[2].innerText = ""; //清空
//            _UN = UNP > 5 ? UNP - 5 : 0; //当前页的范围
//            _USP = UNP + UCF.isp > UDP ? UDP : UNP + UCF.isp;
//            _UAE = U.UF.P.PPage.setPage([_UN, _USP], null, null, UCF); //获取点击事件
//            for (i = _UN; i < _USP; i++) { //范围使用
//                $$("div", { "onclick": function () {
//                    U.UF.P.PPage.exec(i + 1, _UAE[i - _UN], UOD, USN, UNP, UDN, UCF, UDOD);
//                },
//                    "className": "UD_SYFYNO" + ((i + 1 == UNP) ? " UD_SYFYNOO" : ""),
//                    "innerHTML": i + 1
//                }, _UDAD[2]);
//            }
//        }
//        U.selectEl(_UDTD[1]).childs(0, 1).addAttrArray({
//            "onclick": (_UTE = function () {
//                U.UF.P.PPage.PageAchieve(UDE[3], UOD, USN, UNP, UDN, UCF, UDOD, UDP);
//            })
//        }, 8);
//        U.selectEl("input", UDOD).addAttrArray({
//            "onkeyup": function () {
//                U.UF.C.returnkeylogin(null, _UTE);
//            }
//        });
//    }
//    else {
//        _UDOD = $$("div", {
//            "className": "UD_SYFY"
//        });
//        _UDTD = $$("div", {
//            "className": "UD_SYFYL"
//        }, _UDOD);
//        $$("div", {
//            "className": "U_Boom_Img_ys2017 UD_SYFYLO" + (_UCE[0] || ""),
//            "onclick": _UCE[0] ? null : function () {
//                U.UF.P.PPage.exec(1, _UBE[0], UOD, USN, UNP, UDN, UCF, _UDOD);
//            },
//            "title": "首页"
//        }, _UDTD);
//        $$("div", {
//            "className": "U_Boom_Img_ys2017 UD_SYFYLT" + (_UCE[1] || ""),
//            "onclick": _UCE[1] ? null : function () {
//                U.UF.P.PPage.exec(UNP - 1, _UBE[1], UOD, USN, UNP, UDN, UCF, _UDOD);
//            },
//            "title": "上一页"
//        }, _UDTD);
//        if (UCF.isp && UDP > 0) {
//            _UDSD = $$("div", { "className": "UD_SYFYN" }, _UDTD);
//            _UN = UNP > 5 ? UNP - 5 : 0;
//            _USP = UNP + UCF.isp > UDP ? UDP : UNP + UCF.isp;
//            _UAE = U.UF.P.PPage.setPage([_UN, _USP], null, null, UCF); //获取点击事件
//            for (i = _UN; i < _USP; i++) {
//                $$("div", { "onclick": function () {
//                    U.UF.P.PPage.exec(i + 1, _UAE[i - _UN], UOD, USN, UNP, UDN, UCF, _UDOD);
//                },
//                    "className": "UD_SYFYNO" + ((i + 1 == UNP) ? " UD_SYFYNOO" : ""),
//                    "innerHTML": i + 1
//                }, _UDSD);
//            }
//        }
//        $$("div", {
//            "className": "U_Boom_Img_ys2017 UD_SYFYLS" + (_UCE[2] || ""),
//            "onclick": _UCE[2] ? null : function () {
//                U.UF.P.PPage.exec(UNP + 1, _UBE[2], UOD, USN, UNP, UDN, UCF, _UDOD);
//            },
//            "title": "下一页"
//        }, _UDTD);
//        $$("div", {
//            "className": "U_Boom_Img_ys2017 UD_SYFYLF" + (_UCE[3] || ""),
//            "onclick": _UCE[3] ? null : function () {
//                U.UF.P.PPage.exec(UDP, _UBE[3], UOD, USN, UNP, UDN, UCF, _UDOD);
//            },
//            "title": "尾页"
//        }, _UDTD);
//        _UDTD = $$("div", {
//            "className": "UD_SYFYR"
//        }, _UDOD);
//        _UDSD = $$("div", {
//            "className": "UD_SYFYRL"
//        }, _UDTD);
//        $$("span", {
//            "innerHTML": "到"
//        }, _UDSD);
//        _UDGD = $$("div", {}, _UDSD);
//        $$("input", {
//            "type": "text",
//            "onkeyup": [U.UF.C.returnkeylogin, [null, function () {
//                U.UF.P.PPage.PageAchieve(UDE[3], UOD, USN, UNP, UDN, UCF, _UDOD, UDP);
//            } ]]
//        }, _UDGD);
//        $$("span", {
//            "innerHTML": "页"
//        }, _UDSD);
//        $$("div", {
//            "className": "UD_SYFYRZ",
//            "innerHTML": "确定",
//            "onclick": function () {
//                U.UF.P.PPage.PageAchieve(UDE[3], UOD, USN, UNP, UDN, UCF, _UDOD, UDP);
//            }
//        }, _UDTD);

//        $$("div", {
//            "className": "UD_SYFYRR",
//            "innerHTML": UNP + "页"
//        }, _UDTD);
//        UOD.appendChild(_UDOD);
//    }
//}
////函数执行
//U.UF.P.PPage.exec = function (UTF, UFN, UOD, USN, UNP, UDN, UCF, UDOD) {
//    if (UFN != null) {
//        var _UDE = U.UF.P.PPage.main(UOD, USN, UTF, UDN, UCF, true);
//        U.UF.P.PPage.CPage(_UDE[0], UOD, Math.ceil(USN / UDN), UTF, USN, UDN, UCF, UDOD);
//        UFN();
//    }
//}

////输入框设置
//U.UF.P.PPage.PageAchieve = function (UFN, UOD, USN, UNP, UDN, UCF, UDOD, UDP) {
//    var _UN = U.selectEl(event.srcElement).parentElement().find("input")[0].value;
//    if (U.UF.S.Number.test(_UN)) {
//        _UN = _UN.toInt();
//        if (_UN <= UDP && _UN > 0) {
//            if (UNP != _UN) { U.UF.P.PPage.exec(_UN, UFN, UOD, USN, UNP, UDN, UCF, UDOD) };
//        }
//        else {
//            parent.U.Alert("输入范围异常！");
//        }
//    }
//    else {
//        parent.U.Alert("无效输入！");
//    }
//};

////设置页数函数
//U.UF.P.PPage.setPage = function (USN, UNP, UDN, UCF) {
//    var i, j, k, _USE, _UKE, _UGE, _UME = [],
//        _UCE = UCF["fun"], //回调函数
//        _UIP = UCF["page"]; //当前使用页数;
//    if (Array.isArray(USN)) {
//        for (i = USN[0]; i < USN[1]; i++) {
//            _UGE = [];
//            for (j = 0; j < _UCE.length; j++) {
//                _USE = _UCE[j][1];
//                if (_UIP[j] != null) {
//                    _USE = _USE.concat();
//                    _USE[_UIP[j]] = i + 1;
//                }
//                _UGE.push[_UCE[j][0], _USE];
//            }
//            _UME.push(_UGE);
//        }
//        return _UME;
//    }

//    else { //添加事件处理
//        var _UDP = Math.ceil(USN / UDN), //总页数
//                _UDE = [1, UNP - 1, UNP + 1, "$(event.srcElement).parentElement().find('input')[0].value", _UDP]; //前一页后一页处理

//        for (i = 0; i < _UDE.length; i++) {
//            _UGE = [];
//            for (j = 0; j < _UCE.length; j++) {
//                _USE = _UCE[j][1];
//                if (_UIP[j] != null) {
//                    _USE = _USE.concat();
//                    _USE[_UIP[j]] = _UDE[i];
//                }
//                _UGE.push[_UCE[j][0], _USE];
//            }
//            _UME.push(_UGE);
//        }
//        return [_UME, _UDP];
//    }
//}

////控件设置
//U.UF.P.PPage.main = function (UOD, USN, UNP, UDN, UCF, UTF) {
//    var i, j, _USE, _UKE,
//            _UME = U.UF.P.PPage.setPage(USN, UNP, UDN, UCF);
//    if (U.UF.C.isFunction(UTF)) {
//        _USE = UTF(this);
//        _UKE = { //按钮对应事件处理
//            "pre": { "onclick": function () {
//                U.UF.P.PPage.exec(UNP - 1, _UBE[1], UOD, USN, UNP, UDN, UCF);
//            } 
//            }, //上一页
//            "next": { "onclick": function () {
//                U.UF.P.PPage.exec(UNP + 1, _UBE[2], UOD, USN, UNP, UDN, UCF);
//            } 
//            }, //下一页
//            "frit": { "onclick": function () {
//                U.UF.P.PPage.exec(1, _UBE[0], UOD, USN, UNP, UDN, UCF);
//            } 
//            }, //第一页
//            "last": { "onclick": function () {
//                U.UF.P.PPage.exec(UNP + 1, _UBE[2], UOD, USN, UNP, UDN, UCF);
//            } 
//            }, //最后一页
//            "input": [
//                { "onkeyup": [U.UF.C.returnkeylogin, [null, function () {
//                    U.UF.P.PPage.PageAchieve(UDE[3], UOD, USN, UNP, UDN, UCF, null, UDP)
//                } ]]
//                },
//                    { "onclick": function () {
//                        U.UF.P.PPage.PageAchieve(UDE[3], UOD, USN, UNP, UDN, UCF, null, UDP);
//                    } 
//                    }], //输入框 按钮
//            "page": [] //页码按钮 变化样式 当前页的样式
//        };
//        for (i in _USE) {
//            if (_USE.hasOwnProperty(i) && _UKE[i]) {
//                if (Array.isArray(_UKE[i])) {
//                    for (j = 0; j < _UKE[i].length; j++) {

//                    }
//                }
//                else {
//                    for (j in _UKE[i]) {
//                        _USE[i][j] = _UKE[i][j]
//                    }
//                }
//            }
//        }
//    }
//    else if (!UTF) { //  创建分页控件
//        U.UF.P.PPage.CPage(_UME[0], UOD, _UME[1], UNP, USN, UDN, UCF)
//    }
//    return _UME;
//}

////#endregion



////#region

////所有请求的ajax对象.
//U.A.allAjax = [];

////#endregion

///**
//* ajax初始化区域
//*
//* @param  {string} 访问的地址
//* @param  {array} 数据库地址，数据库名，存储过程名，存储过程参数的数组
//* @param  {function} 回调函数
//* @param  {array} 函数传参
//* @returns {object} ajax对象 
//-----------这里的传参第一个为loading元素
//*/
//// 删除了一个参数 UCE
//U.A.Request = $.ajax = function (str, db, cb, arg) {
//    //判断浏览器是否在线联网
//    if (navigator.onLine) {
//        var _ajax, //获取所有的传参,参数说明 win 当前域 、 UR ajax原对象 、 EOR 错误回调函数 、 fun 触发的函数地址 、 UDE 服务器传参 、 cb 回调函数    UPE 回调参数 、 UAE ajax对象属性 、 time当前使用时间
//            _preajax = U.A.allAjax[U.A.allAjax.length - 1]; //ajax对象
//        //判断ajax的时间差，防止恶意用户用循环向服务器不断发送请求，导致服务器瘫痪。
//        //恶意请求大于了50次，则判断此用户有恶意攻击嫌疑。
//        //计算两次ajax请求的时间差
//        var _iftimespan;
//        if (_preajax) {
//            _iftimespan = new Date().getTime() - _preajax.date > 50;
//        }
//        //如果第一次ajax请求，或者ajax请求小于50次。或者2次发送请求的时间差大于50毫秒，都算没有恶意请求。
//        if (!_preajax || _preajax.timespan < 50 || _iftimespan) { //连续发送禁止处理
//            _ajax = new U.A.Request.init(arguments); //生成ajax对象
//            //此处添加二级域名跨域，完全跨域，无跨域的分支。
//            if (_ajax.handleDomain() == true) {
//                return _ajax.create(); //创建连接，无_header分支


//                //                //添加有_header和无_header的两个分支。
//                //                if (_ajax.header) {
//                //                    return _ajax.createHeader(_ajax.header); //创建连接，添加_header的目的是可以自己构建_header
//                //                } else {
//                //                
//                //                }
//            }
//        }
//        else {
//            return { "error": "application has been breached" }; //连接过多错误
//        }
//    } else { U.Alert("网络断开！"); }
//}

///**
//* ajax初始化区域
//*
//* @param  {array} ajax参数
//----------[0] 访问的地址
//----------[1] 服务器传参
//----------[2] 回调函数
//----------[3] 函数传参
//-----------这里的传参第一个为loading元素
//*/
//U.A.Request.init = function (arg) { //初始化Ajax对象
//    /*
//    参数说明 win 当前域 、 UR ajax原对象 、 EOR 错误回调函数 、 fun 触发的函数地址 、 UDE 服务器传参 、 cb 回调函数
//    UPE 回调参数 、 UAE ajax对象属性 、 time当前使用时间
//    */
//    //this.win = window; // win 当前域
//    //ajax原对象{ TO: _UAE, D: this.time, N: this.fun, J: (_UOE && ((new Date().getTime() - _UOE.D) < 50)) ? _UOE.J + 1 : _UOE ? _UOE.J : 0 }
//    //U.A.Request调用示例：U.A.Request("http://cd.1473.cn/php", ["mysql.1473.cn", "CloudSqlTestDb", "selectAllData"],function (r){})
//    this.win = window; // win 当前域
//    this.ajax = null; //ajax原对象{ TO: _UAE, D: this.time, N: this.fun, J: (_UOE && ((new Date().getTime() - _UOE.D) < 50)) ? _UOE.J + 1 : _UOE ? _UOE.J : 0 }  在函数createAjax里面最后一句话会发送此ajax
//    this.err = null; //  err   error是系统关键字
//    this.url = arg[0]; // url   ）。后台地址，形如"http://cd.1473.cn/php"。
//    //ajax向后台请求的传参，其形式为：["mysql.1473.cn", "CloudSqlTestDb", "selectAllData","guid","str"]，包含了数据库地址，数据库名，数据库存储过程名称，数据库参数...如果没有，则新建一个空数组，用法：var e = U.A.Request("http://cd.1473.cn/ss");.则e为后台返回的值。
//    //UDE改成db
//    this.db = arg[1] || [];
//    this.cb = arg[2] || ""; //回调函数  cb   
//    this.cbparams = arg[3]; //回调参数  cbparams
//    //调用方法：U.A.Request(US.AUTH,"UseStudioManage.AddToLoginLog", [US.userInfo.userid || US.EMPTYGUID, US.city.userAllLocation || "", US.ITID], function(){}, [], { type: "Get", "setAsyn": false, "timeout": 1, "CONTENT-TYPE": "application/json" }); //访问日志添加消息
//    this.header = arg[4] || ""; //暂时没有用处。浏览器升级后对ajax的功能进行扩展，加入了"对head头部自定义修改"的功能。CONTENT-TYPE:application/x-www-form-urlencoded;charset=UTF-8.
//    this.time = new Date(); //ajax生成时间..删除，时间保存在第二个参数ajax里面。
//}


//U.A.Request.init.prototype = {
//    /**
//    * Ajax对象创建
//    *
//    * @param  {object} ajax属性
//    */
//    create: function () {
//        //        var _ajax,
//        //            _header = this.header || {}, //header头部设置
//        //            _ajaxtype = _header && _header.type ? _header.type : "GET", //请求格式
//        //            _isasync = U.UF.C.isFunction(this.cb), //默认是同步处理
//        //            _urlandparams = this.toAjaxFormat(), //生成请求参数 数据结构：
//        //            _url = _urlandparams[0], //连接的后台地址 形如"http://cd.1473.cn/php" 
//        //            _db = _urlandparams[1]; //传参参数; 

//        //        //get请求就直接拼接
//        //        if (_ajaxtype.toUpperCase() == "GET") {
//        //            _url += "?" + _db;
//        //        }
//        //        this.ajax = this.createAjax(_url); //生成ajax对象
//        //        _ajax = this.ajax.systemAjax; //获取系统ajax对象
//        //        _ajax.open(_ajaxtype, _url, _isasync); //设置ajax请求方法 url 是否异步
//        //        _header["CONTENT-TYPE"] = _header["CONTENT-TYPE"] || "application/x-www-form-urlencoded;charset=UTF-8"; //请求的type
//        //        //设置请求参数
//        //        for (i in _header) {

//        //            if ("type,setAsyn".indexOf(i) == -1) {
//        //                try {
//        //                    if (i in _ajax) {
//        //                        _ajax[i] = _header[i];
//        //                    } else {
//        //                        _ajax.setRequestHeader(i, _header[i]);
//        //                    } //设置head头部
//        //                } catch (e) { }
//        //            }
//        //        }

//        //        // 指定服务器返回数据的MIME类型 firfox设置兼容
//        //        if (_ajax.overrideMimeType) {
//        //            if (_header["responseType"] == "blob") {
//        //                _ajax.overrideMimeType("text/plain; charset=x-user-defined");
//        //            } else {
//        //                _ajax.overrideMimeType("text/html");
//        //            }
//        //        }
//        //        //发送请求
//        //        _ajax.send(_db);




//        //   this.header ? "" : this.header

//        var i,
//            _url,
//            _isdomain,
//            _db,
//            _ajax,
//            _isasync,
//            r;
//        var _ajaxtype = _header.type; //用户请求类型，默认1473全部是post请求。
//        var _urlandparams = this.toAjaxFormat(); //生成请求参数 数据结构：
//        _url = _urlandparams[0]; //连接的后台地址 形如"http://cd.1473.cn/php" 
//        _db = _urlandparams[1]; //传参参数;  
//        //如果不传递回调函数，则为同步请求，示例：U.A.Request(US.AUTH,"UseStudioManage.AddToLoginLog", [US.userInfo.userid || US.EMPTYGUID, US.city.userAllLocation || "", US.ITID]);。返回json数据，一直等待服务器返回，如果服务器执行1分钟，页面停顿1分钟。
//        if (U.UF.C.isFunction(this.cb)) {
//            _isasync = true; //函数是否异步
//        }
//        //如果请求为get
//        if (_ajaxtype.toUpperCase() == "GET") {
//            _url += "?" + _db;
//        }
//        this.ajax = this.createAjax(_url); //生成ajax对象
//        _ajax = this.ajax.systemAjax; //获取系统ajax对象
//        _ajax.open(_ajaxtype, _url, _isasync); //设置ajax请求方法 url 是否异步

//        _header["CONTENT-TYPE"] = _header["CONTENT-TYPE"] || "application/x-www-form-urlencoded;charset=UTF-8"
//        //设置请求参数
//        for (i in _header) {
//            if ("type,setAsyn".indexOf(i) == -1) {
//                try {
//                    if (i in _ajax) {
//                        _ajax[i] = _header[i];
//                    } else {
//                        _ajax.setRequestHeader(i, _header[i]);
//                    } //设置head头部
//                } catch (e) { }
//            }
//        }
//        // 指定服务器返回数据的MIME类型 firfox设置兼容
//        if (_ajax.overrideMimeType) {
//            if (_header["responseType"] == "blob") {
//                _ajax.overrideMimeType("text/plain; charset=x-user-defined");
//            } else {
//                _ajax.overrideMimeType("text/html");
//            }
//        }
//        //发送请求
//        _ajax.send(_db);

//        //得到服务器返回的值，一般为json，也可能为字符串。如果是异步，则走异步逻辑，否则走同步逻辑
//        if (_isasync) {
//            r = this["setAsyn"]();
//        } else {
//            r = this["getAjaxData"]();
//        }
//        //返回
//        return _isdomain;
//    },
//    /**
//    * Ajax对象创建
//    *
//    * @param  {object} ajax属性
//    */
//    //    create: function () {
//    //        var _header = {};
//    //        var i,
//    //            _url,
//    //            _isdomain,
//    //            _db,
//    //            _ajax,
//    //            _isasync,
//    //            r;
//    //        var _ajaxtype = "POST"; //用户请求类型，默认1473全部是post请求。
//    //        var _params = this.toAjaxFormat(); //生成请求参数 数据结构：
//    //        _url = _params[0]; //连接的后台地址 形如"http://cd.1473.cn/php" 
//    //        _db = _params[1]; //传参参数;  
//    //        //如果不传递回调函数，则为同步请求，示例：U.A.Request(US.AUTH,"UseStudioManage.AddToLoginLog", [US.userInfo.userid || US.EMPTYGUID, US.city.userAllLocation || "", US.ITID]);。返回json数据，一直等待服务器返回，如果服务器执行1分钟，页面停顿1分钟。
//    //        if (U.UF.C.isFunction(this.cb)) {
//    //            _isasync = true; //函数是否异步
//    //        }
//    //        //如果请求为get
//    //        if (_ajaxtype.toUpperCase() == "GET") {
//    //            _url += "?" + _db;
//    //        }
//    //        //设置请求超时时间
//    //        if (_isasync) {
//    //            // 给_header对象添加属性
//    //            _header.timeout = 90000;
//    //            _header.ontimeout = U.UF.C.apply(this, function () { this.asyn(); });
//    //        }

//    //        this.ajax = this.createAjax(_url); //生成ajax对象
//    //        _ajax = this.ajax.systemAjax; //获取系统ajax对象
//    //        _ajax.open(_ajaxtype, _url, _isasync); //设置ajax请求方法 url 是否异步

//    //        // 指定服务器返回数据的MIME类型 firfox设置兼容
//    //        _ajax.setRequestHeader("CONTENT-TYPE", "application/x-www-form-urlencoded;charset=UTF-8");
//    //        // 指定服务器返回数据的MIME类型 firfox设置兼容
//    //        if (_ajax.overrideMimeType) {
//    //            _ajax.overrideMimeType("text/html");
//    //        }

//    //        //发送请求
//    //        _ajax.send(_db);

//    //        //得到服务器返回的值，一般为json，也可能为字符串。
//    //        if (_isasync) {
//    //            r = this.setAsyn();
//    //        } else {
//    //            r = this.getAjaxData();
//    //        }
//    //        //返回
//    //        return r;
//    //    },
//    /**
//    * 根据请求的url判断域名是否存在跨域。三种跨域情况
//    * @return 
//    */
//    handleDomain: function () {
//        //1、二级域名跨域，一般是a.1473.cn访问b.1473.cn。。可能是正常访问，也可能是iframe访问。，
//        //2、完全跨域。www.a.com访问www.b.com。  
//        //3、没有跨域的情况
//        var _isdomain, _url, _frame;
//        var _params = this.toAjaxFormat(); //生成请求参数 数据结构：
//        _url = _params[0]; //连接的后台地址 形如"http://cd.1473.cn/php" 
//        _isdomain = this.isDomain(_url);
//        //1473跨域处理，判断是否是1473域，如果不是，则是外域调用
//        if (_isdomain[0] && !_isdomain[1]) { // 判断是否是1473主域
//            //如果是1473域的处理
//            _frame = window.frames; //所有加载的域，对1473域下所有iframe进行循环，目的是找到可跨域的iframe。
//            for (i = 0; i < _frame.length; i++) {
//                try {
//                    if (!_url.indexOf(_frame[i].location.protocol + "//" + _frame[i].location.host)) { //找到指定的跨域
//                        return _frame[i].U.A.Request(this.url, this.db, this.cb, this.cbparams, this.header); //跨域获取
//                    }
//                } catch (e) { }
//            }
//        }
//        //完全跨域判断非1473的域名， 
//        else if (!_isdomain[1] && _url.indexOf("1473.cn") > -1 && U.selectEl("#U_Domain")[0]) { //其他域名跨域处理
//            //其他站点，跨域形式访问：例如：http://a.com/ 在页面中调用U.A.Request(US.AUTH,"UseStudioManage.AddToLoginLog", [US.userInfo.userid || US.EMPTYGUID, US.city.userAllLocation || "", US.ITID]);
//            this.goDomain(); //外站跨域调用
//            return false;
//        }
//        return true;
//    },
//    //把传参格式转换为Ajax请求格式
//    //              刑如：US.AUTH,"AddToLoginLog", [US.userInfo.userid , US.city.userAllLocation , US.ITID]  转换为下面的格式
//    //              格式："http://main.1473.cn/Uses.ashx",US.userInfo.userid || US.EMPTYGUID +"&" + US.city.userAllLocation || ""+ "&" + US.ITID, "http://main.1473.cn/Uses.ashx"（默认请求地址，如果第一个参数不在U.A.backAddress中，则使用第三个）
//    /*
//    * @return  {array} 域、 加密参数
//    */
//    toAjaxFormat: function () {
//        var _userinfo,
//            _useurl,
//            _url = this.url, //这个是请求参数
//            _params = U.UF.C.urlEncode(this.db.concat()), //参数进行加密
//            _source = _url.indexOf(":") > -1 && U.UF.C.isUrl(_url), //判断来源是否是链接
//            _requestarr = _url.split("."); //这里拆分1473的请求
//        //通过链接方式去访问
//        //       if (_source) {
//        _useurl = _url;
//        _params = "mode=" + _params; //设置传参
//        //        }
//        //        //相对路径访问方式
//        //        else {
//        //            _useurl = window.location;
//        //            _useurl = window.location ? _useurl.protocol + "//" + _useurl.host + "/" + _url : "./" + _url;
//        //            _params = "mode=" + _params;
//        //        }
//        //请求中添加用户的信息
//        try {
//            //获取全局变量US
//            if (parent.US) {
//                _userinfo = top.US.userInfo; //获取用户的信息
//                //如果用户的信息存在那么拼接用户的信息
//                if (_userinfo && _userinfo.UserId) {
//                    _params += "&UserId=" + _userinfo.UserId + "&LoginId=" + _userinfo.LoginId;
//                }
//                //设置1473项目传参的id
//                _params += "&PageId=" + US.pageId + "&SystemId=" + US.systemId;
//            }
//        }
//        catch (e) { }
//        //请求的地址，参数，请求的后台函数名
//        return [_useurl, _params];
//    },

//    //完全跨域设置（此处非1473域名区域）处理区域
//    goDomain: function () {
//        // 获取回调参数
//        var _loading = this.cbparams ? this.cbparams[0] : null;
//        // 加载loading
//        if (_loading) {
//            U.UF.DL.loading(_loading[0])
//        } else {
//            U.UF.DL.loading(_loading, _loading[1])
//        }
//        // (_UDE) && (U.UF.DL.loading(_UDE[0] || _UDE, _UDE[1])); //设置loading
//        // 页面消息传递
//        new U.UF.EV.message({
//            "obj": "#U_Domain",
//            "Sender": true, //消息发送
//            "me": U.UF.C.apply(this, function (_data) { //接受到跨域的ajax的回调处理
//                var _dataarr = _data[2].split("=");
//                //后台设置了cookie 前台同时响应
//                if (_dataarr[1] == "") {
//                    U.UF.Cookie.del(_dataarr[0]);
//                } else {
//                    U.UF.Cookie.set(_data[2]);
//                }
//                //document.wincookie = _data[2]; //记录cookie
//                if (this.asyn) {//回调函数
//                    this.asyn(_data[0])
//                }
//            })
//        }).post([this.url, this.db], "domain"); //跨域传参
//    },

//    /**
//    * 获取链接地址
//    *
//    * @param  {url} 连接地址
//    -----------[0] 是否为1473域
//    -----------[0] 是否为主域
//    */
//    isDomain: function (URL) {
//        var _url;
//        //用本地html打开网站时，没有window.location。
//        if (window.location) {
//            //获取当前域名地址栏，不包含目录结构。例如：
//            _url = window.location.protocol + "//" + window.location.host; //当前域
//            if (_url.indexOf("1473.cn") > -1 && URL.indexOf("1473.cn") > 0) {
//                return [true, !URL.indexOf(_url)];
//            } else {
//                return [false, false];
//            }
//        }
//    },

//    /**
//    * 创建Ajax对象
//    *
//    * @param  {url} 连接地址
//    * @returns {object} ajax对象
//    */
//    createAjax: function (url) {
//        //从已经存在的ajax对象中找到已经结束请求的ajax对象，重新使用，避免ajax对象没有释放，重新创建的问题。
//        //Ajax兼容  

//        var i, _ajax, _xhr, _url, _ajaxobj = U.A.allAjax,
//            _preajax = _ajaxobj[_ajaxobj.length - 1],
//            _xhr = ["Msxml2.XMLHTTP.6.0", "Msxml2.XMLHTTP", "Microsoft.XMLHTTP"]; //ajax对象
//        // 获取当前域名
//        if (window.location) {
//            _thisUrl = window.location.protocol + "//" + window.location.host;
//        } else {
//            _thisUrl = "";
//        }
//        //获取可以使用的Ajax对象
//        for (i = 0; i < _ajaxobj.length; i++) { //在ajax里找到使用对象
//            if ((_ajax = _ajaxobj[i].systemAjax).readyState == 4) {
//                _ajax.onreadystatechange = function () { }; //设置回调为空
//                _ajax.abort(); //停止
//                return _ajaxobj[i];
//            }
//        }
//        //这里创建Ajax对象
//        try { _ajax = new window.XMLHttpRequest(); } //浏览器默认ajax对象
//        catch (e) {
//            for (i = 0; i < _xhr.length; i++) { //ie6-系列使用
//                try {
//                    _ajax = new ActiveXObject(_xhr[i]);
//                    break;
//                } catch (e) { }
//            }
//        }
//        //h5创建跨域ajax
//        if (url.indexOf(_thisUrl) == -1 && window.XDomainRequest) {
//            _ajax = new window.XDomainRequest();
//        }
//        //疑似非法ajax请求次数记录
//        var _timespan;
//        //如果当前发送的ajax请求和上一次发送的ajax请求时间小于0.05秒。则判断为循环非法操作。
//        if (_preajax && ((new Date().getTime() - _preajax.date) < 50)) {
//            _timespan = _preajax.timespan + 1; //恶意攻击+1.
//        } else {
//            if (_preajax) {
//                _timespan = _preajax.timespan;
//            } else {
//                _timespan = 0;
//            }
//        }
//        //(_preajax && ((new Date().getTime() - _preajax.D) < 50)) ? _preajax.J + 1 : _preajax ? _preajax.J : 0;
//        //生成ajax请求
//        var ajax = {
//            systemAjax: _ajax, //系统ajax  new window.XMLHttpRequest();  //systemajax
//            date: this.time, //当前时间 new Date();    //date
//            fun: this.url, //向后台发送请求的函数名称。  //fun
//            timespan: _timespan //与上一次发送Ajax请求的时间差距。  //timespan
//        };
//        _ajaxobj.push(ajax); //把这次的ajax请求记录到数组，目的是方便以后获取查询过的ajax。1、为了找错误，2、为了判断ajax的时间差，防止恶意用户用循环向服务器不断发送请求，导致服务器瘫痪。
//        //return (_UDE[_UDE.length] = { TO: _UAE, D: this.time, N: this.fun, J: (_UOE && ((new Date().getTime() - _UOE.D) < 50)) ? _UOE.J + 1 : _UOE ? _UOE.J : 0 });
//        return ajax;
//    },
//    //设置异步请求
//    setAsyn: function () {
//        var _ajax = this.ajax.systemAjax, //ajax对象
//            _loading = this.cbparams, //回调参数 loading
//            _isundefined = U.UF.Ut.isUndefined(_ajax.onload), //判断兼容问题
//            _cb;
//        if (_isundefined) {
//            //回调函数设置
//            _cb = U.UF.C.apply(this, function () {
//                if (this.ajax.systemAjax.readyState == 4) {//已经加载成功
//                    this.asyn();
//                }
//            });
//        }
//        else {
//            _cb = U.UF.C.apply(this, function () {
//                this.ajax.systemAjax.status = 200; //设置成功状态
//                this.asyn(); //调用跨域统一处理
//            }); //回调函数设置
//        }
//        // 设置loading
//        if (_loading && _loading[0]) {
//            if (_loading[0][0]) {
//                U.UF.DL.loading(_loading[0][0], _loading[0][1]);
//            } else {
//                U.UF.DL.loading(_loading[0], _loading[0][1]);
//            }
//        }
//        // (_cbParams && _cbParams[0]) && (U.UF.DL.loading(_cbParams[0][0] || _cbParams[0], _cbParams[0][1]));
//        //设置错误和异步请求
//        // 设置ajax回调函数
//        if (_isundefined) {
//            _ajax.onreadystatechange = _cb;
//        } else {
//            _ajax.onload = _cb;
//        }
//        // 设置ajax错误时的处理
//        try {
//            _ajax.onerror = U.UF.C.apply(this, function () {
//                this.ajax.systemAjax.status = 500; //设置错误为500
//                this.asyn(); //异步处理
//            });
//        } catch (e) { }
//    },
//    /**
//    * 服务器异步加载成功后，得到返回值，取消loading,然后回调.
//    *
//    * @param  {boolean} 是否可以直接通过 不进行ajax流程判断
//    * @param  {string} 绕过ajax流程 传参
//    */
//    asyn: function (data) {
//        try {
//            //ajax请求成功该请求的请求数改成0
//            if (this.ajax) {
//                this.ajax.timespan = 0;
//            }
//            var _loading = this.cbparams, //loading 元素
//                _data = this.getAjaxData(data), //ajax string 数据 生成 json数据集
//                _timeSpan = (new Date()).getTime() - this.time.getTime(); //ajax总共耗时
//            // 取消loading
//            if (_loading && _loading[0]) {
//                if (_loading[0][0]) {
//                    U.UF.DL.uploading(_loading[0][0]);
//                } else {
//                    U.UF.DL.uploading(_loading[0]);
//                }
//            }
//            // (_UPE && _UPE[0]) && (U.UF.DL.uploading(_UPE[0][0] || _UPE[0])); //取消loading
//            //访问时间太长或者出现了错误 输出控制台
//            if (_timeSpan > 1000 || _data.error) {
//                (U.UF.C.console({ "T": _timeSpan, "N": this.url, "V": _data.error }));
//            }
//            //关闭连接
//            if (_data.httpRequest.abort) {
//                _data.httpRequest.abort();
//            }
//            //回调数据
//            if (this.cb && _data.value !== null) {
//                this.cb.call(this.win, _data)
//            }
//        } catch (e) { U.UF.C.console(e); }
//    },

//    /**
//    * 生成数据
//    *
//    * @param  {string} 绕过ajax流程 传参
//    * @return  {string} 数据参数
//    */
//    getAjaxData: function (data) {
//        var _iserror, _ajax;
//        //获取ajajx对象
//        if (this.ajax) {
//            _ajax = this.ajax.systemAjax;
//        }
//        else {
//            _ajax = {};
//        }
//        var _ajaxattr = { httpRequest: _ajax, status: null, value: null, _context: this.cbparams };  //ajax对象使用
//        //请求成功处理
//        if (_ajax.status == 200) {
//            _ajaxattr.value = data || this.getBackStrToJson(); //生成返回的参数
//        }
//        //错误处理.
//        else {
//            _ajaxattr.status = {
//                "status": _ajax.status,
//                "statusText": _ajax.statusText
//            };
//        }
//        return _ajaxattr; //生成数据返回
//    },

//    /**
//    * 得到后台返回的字符串，再把后台返回的字符串生成一个json对象
//    *
//    * @return  {object} json值
//    */
//    getBackStrToJson: function () {
//        var _ajax = this.ajax.systemAjax, //ajax对象
//            _resXml = _ajax.responseXML; //xml对象
//        //如果服务器返回的为xml对象
//        if (_resXml) {
//            _resXml = _resXml.xml
//        }
//        if (!_resXml) {
//            _resXml = _ajax.responseText; //返回的值
//            _resXml = U.UF.C.toJson(_resXml); //生成对象
//        }
//        return _resXml;
//    }
//}




//#endregion



//#region


///**
//* Flash上传初始化
//*
//*/
//U.UF.UP.FOnload = function () {
//    try {
//        var _obj = U.UF.UP.FTF; //当前上传的元素
//        _obj["EL"].SetStage(_obj["WH"], _obj["FT"], _obj["GS"] || "*"); //加载插件初始化
//        return true;
//    }
//    catch (e) {
//        return false;
//    }
//}

///**
//* 上传的错误提示
//*
//* @param  {error} 错误信息
//*/
//U.UF.UP.FLEX = function (err) {
//    U.Alert(err);
//    U.UF.C.console(err); //错误函数控制台处理
//}

///**
//* 添加上传文件 上传文件的显示
//*
//* @param  {error} 错误信息
//*/
//U.UF.UP.FLAdd = function (UDE, UL) {
//    var _UDOD = U.UF.UP.FTF.EL, //当前上传的元素
//    _UDID = _UDOD.ID || _UDOD.name;
//    if (U.UF.UP.FTF[_UDID] && U.UF.UP.FTF[_UDID].FT && U.UF.UP.FTF[_UDID].FT["select"]) {
//        U.UF.UP.FTF[_UDID].FT["select"](UDE, UL);
//    }
//}


////上传所有文件完毕
//U.UF.UP.FLACP = function (UFL) {
//    var _UDOD = U.UF.UP.FTF.EL,
//    _UDID = _UDOD.ID || _UDOD.name;
//    if (U.UF.UP.FTF[_UDID] && U.UF.UP.FTF[_UDID].FT && U.UF.UP.FTF[_UDID].FT["AFCP"]) {
//        U.UF.UP.FTF[_UDID].FT["AFCP"](UFL);
//    }
//}

////上传的进度条
//U.UF.UP.FLJD = function (UDE, FID) {
//    var _UDOD = U.UF.UP.FTF.EL,
//    _UDID = _UDOD.ID || _UDOD.name;

//    if (U.UF.UP.FTF[_UDID] && U.UF.UP.FTF[_UDID].FT && U.UF.UP.FTF[_UDID].FT["progress"]) {
//        U.UF.UP.FTF[_UDID].FT["progress"](UDE, FID);
//    }
//}

////上传文件成功同时服务端返回了数据
//U.UF.UP.FSLCP = function (UDAT, FID) {
//    var _UDOD = U.UF.UP.FTF.EL,
//    _UDID = _UDOD.ID || _UDOD.name;

//    if (U.UF.UP.FTF[_UDID] && U.UF.UP.FTF[_UDID].FT && U.UF.UP.FTF[_UDID].FT["getData"]) {
//        U.UF.UP.FTF[_UDID].FT["getData"](UDAT, FID);
//    }
//}

////上传文件判断是否存在
//U.UF.UP.IsFUp = function (UWJL, FID) {
//    var _UDOD = U.UF.UP.FTF.EL,
//    _UDID = _UDOD.ID || _UDOD.name;

//    if (U.UF.UP.FTF[_UDID] && U.UF.UP.FTF[_UDID].FT && U.UF.UP.FTF[_UDID].FT["FUP"]) {
//        U.UF.UP.FTF[_UDID].FT["FUP"](UWJL, FID);
//    }
//}

////上传单个文件完毕
//U.UF.UP.FLCP = function (data) {
//    U.Alert("等待服务器的响应...");
//}
//#endregion


/**
* 设置文件下载
*
* @param  {string} 上传成功回调函数 
* @param  {string} 上传成功回调函数 
*/
//U.UF.UP.Down = function (str1, str2) {
//    if ("createElementNS" in document) { //html5 文件另存为
//        if (!str2) {
//            str2 = document.documentElement.outerHTML
//        };
//        var url2,
//        _url1 = window.URL || window.webkitURL || window,
//        _str = new Blob[str2];
//        url2 = document.createElementNS("http://www.w3.org/1999/xhtml", "a");
//        url2.href = _url.createObjectURL(_str);
//        url2.download = str1;
//        U.UF.EV.simulateMouseClicks(url2, "click");
//    }
//    else { //IE文件另存为
//        if (str2) {
//            var _iframe = $$("iframe",
//            {
//                "display": "none"
//            });
//            U.UF.C.iframeSameDomain(_iframe, str2, function () {
//                _iframe.contextWindow.document.execCommand("SaveAs");
//            });
//        }
//        else {
//            document.execCommand("SaveAs");
//        } //当前文档保存
//    }
//}


/**
* 根据条件，对json数组进行排序
*
* @param  {array} 需要进行选择的json数组。 
* @param  {number} 排序方式 1正序 -1倒序
* @return  {string} 排序的条件，json数组中的键名  
实例一
var a = [{id:3},{id:1},{id:2}]; 
U.Json.sort(a,"id");
*/
U.Json.sort = function (arr, key, isreverse) { //排序
    isreverse = isreverse || 1;
    arr = arr.sort(function (obj1, obj2) {
        var _value,
            _type, //比较大小的类型
            _isobj = U.UF.C.isObject(obj1); //判断比较的大小是否为对象
        //对象的大小匹配
        if (_isobj) {
            _type = U.UF.C.getType(obj1[key] || obj2[key]).capitalizeFirstLetter(); //由于类型的值有可能是null或者是undefined，判断两种比较安全
            _value = U.UF.Ut["compare" + _type](obj1[key], obj2[key]); //得到匹配的大小
        }
        //非对象的处理方式 U.UF.Ut.compare+type 是一些列的对象比较大小的方法
        else {
            _type = U.UF.C.getType(obj1).capitalizeFirstLetter();
            _value = U.UF.Ut["compare" + _type](obj1, obj2); //得到匹配的大小
        }
        //isreverse 用于判断倒序还是正序，如果是-1就是倒序，如果是1就是正序
        _value = isreverse * (_value ? 1 : -1);
        return _value;
    });
    return arr;
}


/**
* 判断是否为错误
*
* @param  {Error} 错误对象值
* @return  {boolean} 是否为错误类型
*/
U.UF.Ut.isError = function (UDE) {
    return U.UF.C.isObject(UDE) && U.UF.C.objectToString(UDE) == "[object Error]";
}


/**
* 判断是否为正则
*
* @param  {RegExp} 正则值
* @return  {boolean} 是否为RegExp
*/
U.UF.Ut.isRegExp = function (UDE) {
    return U.UF.C.isObject(UDE) && U.UF.C.objectToString(UDE) == "[object RegExp]";
}


/**
* 判断是否为Undefined
*
* @param  {number} 判断数组是否有值
* @return  {boolean} 是否为number
*/
U.UF.Ut.isUndefined = function (UDE) {
    return (UDE === void 0);
}


/**
* 判断是否是无限循环数字
*
* @param  {number} 判断数组是否有值
* @return  {boolean} 是否为number
*/
U.UF.Ut.isFinite = function (UDE) {
    return !isNaN(parseFloat(UDE)) && isFinite(UDE);
}

/**
* 判断是否为NaN
*
* @param  {array} 判断数组是否有值
* @return  {boolean} 是否为number
*/
U.UF.Ut.isNaN = function (UDE) {
    return UDE.toString() == 'NaN'
}


/**
* 判断是否为字符串数字
*
* @param  {array} 判断数组是否有值
* @return  {boolean} 是否为number
*/
U.UF.C.isStringInt = function (UDE) {
    return U.UF.C.isNumber(UDE) || U.UF.S.Num.test(UDE);
}

/**
* 判断是否为空
*
* @param  {object} 判断内容是否为空
* @return  {boolean} 是否为null
*/
U.UF.Ut.isNull = function (UDE) {
    return UDE === null;
}



/**
* 判断是否为bool
*
* @param  {array} 判断数组是否有值
* @return  {boolean} 是否为boolean值
*/
U.UF.Ut.isBoolean = function (UDE) {
    return typeof UDE === "boolean";
}


/**
* 判断数组是否可用
*
* @param   {array} 判断数组是否有值
* @return  {boolean} 是否为有值数组
*/
U.UF.Ut.isArrayLike = function (UDE) {
    return Array.isArray(UDE) && UDE.length > 0;
}

/**
* 判断是否支持播放
*
* @param  {string}  指定的格式 mp3、mpo4
* @return  {number}  是否支持改格式播放
-----------[0] 不支持
-----------[1] 支持
*/
U.UF.C.isPlay = function (type) {
    var _video = U.MD.V.vi(); //获取h5视频播放对象
    //判断浏览器是否支持video标签
    if (_video) {
        if (_video.isPlay(type, $$("video"))) {
            return 1;
        };
        return 0;
    }
    return _video;
}

//#region RadioList

//选择框使用
U.UF.UI.RadioList = function (UDOD, UDE, cb) {
    return new U.UF.UI.RadioList.init(UDOD, UDE, cb);
}

U.UF.EV.addPrototype(U.UF.UI.RadioList,
    U.UF.UI.RadioList.init = function (UDOD, UDE, cb) {
        this.UDTD;
        this.UDE = UDE;
        this.UDOD = UDOD;
        this.cb = cb;
        this.create(UDOD);
    },
    U.UF.UI.RadioList.create = function (UDOD) {
        var i, _UDTD, _UDE = this.UDE,
            _UN = Guid.guidNoDash(),
            _UDFD = $$("frag");
        if (_UDE) {
            UDOD.innerText = "";
            for (i in UDE) {
                if (UDE.hasOwnProperty(i)) {
                    _UDTD = $$("div", {
                        "innerHTML": UDE[i],
                        "style": {
                            "cssText": "margin-left:5px;"
                        }
                    }, _UDFD);
                    _UDTD = $$("input", {
                        "type": "radio",
                        "value": i,
                        "name": _UN,
                        "checked": i ? false : true,
                        "onclick": function () { this.chang(); }
                    }, _UDTD);
                    if (!i) { this.UDTD = _UDTD };
                }
            }
            UDOD.appendChild(_UDFD);
        } else {
            _UDTD = U.selectEl("input[type='radio']", UDOD).addAttrArray({
                "name": _UN,
                "onclick": function () { this.chang(); }
            });
            for (i = 0; i < _UDTD.length; i++) {
                if (_UDTD[i].checked) {
                    this.UDTD = _UDTD[i];
                    break;
                }
            }
        } //设置相同的name
    },
    U.UF.UI.RadioList.value = function () {
        return this.UDTD.value;
    }, //当前聚焦元素的值
    U.UF.UI.RadioList.element = function () {
        return this.UDTD;
    }, //当前聚焦元素
    U.UF.UI.RadioList.chang = function () {
        var _UDOD = event.srcElement;
        if (_UDOD != this.UDTD) { this.UDTD = _UDOD, (this.cb) && (this.cb(_UDOD)) };
    } 
//改变事件
//    U.UF.C.AddObj(U.UF.UI.RadioList, {
//        init: function (UDOD, UDE, cb) {
//            this.UDTD;
//            this.UDE = UDE;
//            this.UDOD = UDOD;
//            this.cb = cb;
//            this.create(UDOD);
//        }, 
//    //生成RadioList
//    create: function (UDOD) {
//        var i, _UDTD, _UDE = this.UDE,
//            _UN = Guid.guidNoDash(),
//            _UDFD = $$("frag");
//        if (_UDE) {
//            UDOD.innerText = "";
//            for (i in UDE) {
//                if (UDE.hasOwnProperty(i)) {
//                    _UDTD = $$("div", {
//                        "innerHTML": UDE[i],
//                        "style": {
//                            "cssText": "margin-left:5px;"
//                        }
//                    }, _UDFD);
//                    _UDTD = $$("input", {
//                        "type": "radio",
//                        "value": i,
//                        "name": _UN,
//                        "checked": i ? false : true,
//                        "onclick": function () { this.chang(); }
//                    }, _UDTD);
//                    if (!i) { this.UDTD = _UDTD };
//                }
//            }
//            UDOD.appendChild(_UDFD);
//        } else {
//            _UDTD = U.selectEl("input[type='radio']", UDOD).addAttrArray({
//                "name": _UN,
//                "onclick": function () { this.chang(); }
//            });
//            for (i = 0; i < _UDTD.length; i++) {
//                if (_UDTD[i].checked) {
//                    this.UDTD = _UDTD[i];
//                    break;
//                }
//            }
//        } //设置相同的name
//    },
//    value: function () {
//        return this.UDTD.value;
//    }, //当前聚焦元素的值
//    element: function () {
//        return this.UDTD;
//    }, //当前聚焦元素
//    chang: function () {
//        var _UDOD = event.srcElement;
//        if (_UDOD != this.UDTD) { this.UDTD = _UDOD, (this.cb) && (this.cb(_UDOD)) };
//    } //改变事件
));

U.UF.UI.RadioList.init.prototype = U.UF.UI.RadioList.prototype;

//#endregion