CocoRoboDesktop/js/NetworkPromotion/NULL/NotUse.js

//----------------------------------------------------

/*-----------------------------------------未被使用的函数-------------------------------------------------------------------------------*/
//模块化编程，未使用到
U.UF.C.define = function () {
    var get, _UT, _UAE, _UME = {}, _ = function (UA, UB, UC) { return new _UAE.init(UA, UB, UC); } //require, exports, module   
    _.prototype = _UAE = {
        entity: {},
        init: function (UA, UB, UC) { //初始化使用
            var _UDE, _UL = arguments.length;
            _UDE = _UL == 1 ? "" : "";
        },
        load: function (URE) { //预加载模块
            var _UPE = this.path(URE), _UAE = (this.entity[_UPE] = new _UT(_UPE, this)); //获取值
            U.UF.DL.asynLoadJs(_UPE, "js", U.UF.C.apply(this, [[this.cb]])); //获取
        },
        cb: function () { //加载成功 
        },
        path: function (URE) { //获取路径
            var i, _UTH, _UPE = "", _UDE = URE.split("/");
            switch (_UDE[0]) { case "": _UPE = _UME.base || window; break; case ".": _UPE = ""; break; default: break; }
            _UPE += (_UDE.length > 1 ? (_UME.paths[(_UTH = _UDE.slice(-1).join("/"))] || _UTH) : "") + (_UME.alias[_UDE[0]] || _UDE[0]); _("", "", _UPE);
            return _UPE;
        },
        get: function (UPE) { //获取实体值
            return this.entity[_UPE] || (this.entity[_UPE] = new _UT(_UPE, this));

        },
        set: function () { //设置值
        }
    };
    get = function () { }
    //模块记录类
    _UT = function () { var _UDE = arguments;U.UF.C.AddObj(this, { url: _UDE[0], et: _UDE[1] }); }
    //方法
    _UT.prototype = {
        get: function () { //搜索
        },
        set: function () { //设置
        }
    }
    //配置文件
    _.config = function (UDE) {
        var i, _UAE; _UME = UDE || { base: "./", alias: {}, vars: {}, map: [], preload: [], charset: "utf-8", paths: {} }; //模块初始化 base 路径 alias 识别 vars 变量映射 map 路径映射 preload预加载 charset 编码 paths路径配置
        _UAE = _UME.preload; for (i = 0; i < _UAE.length; i++) { _.use(_UAE[i]); } //初始化
    }
    //引用
    _.use = function (URE) { _(URE); }
    _UAE.init.prototype = _UAE; return _;
}


/**
* 判断元素是否是上级元素的的子元素
*
* @param  {element} 该元素为父元素
* @param  {element} 需要判断的元素
* @return  {boolean} 获取元素的大小 
*/
/*U.UF.EL.isChild = function (UDOD, UDTD) {
if (UDOD && UDTD) {
if (UDOD.contains) { //ie chrome 兼容
if (UDOD.contains(UDTD)) {
return true;
}
}
else if (UDOD.compareDocumentPosition) { //firefox
if (!(!!(UDOD.compareDocumentPosition(UDTD)))) {
return true;
}
}
}
return false;
}*/

/**
* 获取当前元素上级的可编辑元素
*
* @param  {element} 当前元素
* @return  {element} 可编辑的元素 
*/
/*U.UF.EL.getAncestorEditElement = function (UDOD) {
var _UDBD = document.body;
while (UDOD && _UDBD != UDOD) {
if (UDOD.tagName) {
if ("textarea,input".indexOf(UDOD.tagName.toLocaleLowerCase()) > -1 || UDOD.contentEditable == "true") { //可编辑元素
break;
}
}
UDOD = U.selectEl(UDOD).Parent();
}
return UDOD;
}*/

/**
* 获取children不为文本
*
* @param  {element} 当前元素
* @param  {string} 父亲的id
* @return  {array} 获取所有的子节点 
*/
/*U.UF.EL.getChildrenNoText = function (UAE, UTP) {
var i, //用于循环
_UDE = []; //用于存放数据且返回
for (i = 0; i < UAE.length; i++) {
if (UAE[i].nodeType == 1 && (!UTP || UTP.indexOf(UAE[i].tagName.toLowerCase()) == -1)) {
_UDE.push(UAE[i])
};
}
return _UDE;
}*/

/**
* 获取元素offsetParent 兼容ie8-
*
* @param  {element} 元素
* @param  {boolean} 是否从上级开始找起
* @param  {string}  规定的position值
* @return  {elememt}  offsetParent
*/
/*U.UF.EL.offsetParent = function (UDOD, UTF, UPT) {
var _UTP, _UDBD = document.body;
(!UTF) && (UDOD = UDOD.offsetParent);
while (UDOD && UDOD != _UDBD) {
_UTP = U.UF.EL.getStyle(UDOD, "position");
if ((!UPT && _UTP != "static") || (_UTP == UPT)) {
break;
}
UDOD = UDOD.offsetParent;
}
return UDOD || _UDBD;
}*/


//#region 首页播放器
//播放器用户信息区域
U.UF.MPlayer.NBF = function (UDE, UIF, UTF, UAE) {
    U.UF.MPlayer.SYBFYY(UDE, null, UTF, UIF, UAE); U.UF.MPlayer.JJYYSJ(0); //加载音乐
}

//直接播放音乐
U.UF.MPlayer.SYBFYY = function (UDE, UDMD, UTF, UIF, UAE) {
    var _UGE = U.MD.D.H.ET["FL"], _UDOD = U.selectEl("#UD_MP"), _UDTD = _UDOD.find(".UD_MPRLSL").find("div"); UIF = UIF || (US.userInfo.userid ? US.userInfo : UDE);
    if (_UGE["Entity"] != UDE) { //切换歌曲
        U.selectEl(_UDTD.find("img", 0)[0] || $$("img", {}, _UDTD[0])).addAttrArray({ "onerror": U.MD.C.imgError, "title": _UDTD[4].innerText = UIF.UserNickName || UIF.UserName, "alt": _UDTD[4].innerText, "src": U.MD.C.getHeadImage(UIF.UserThumbnailImageHead) });
        _UDTD[1].style.display = "block"; _UDTD[5].innerText = UDE.UserallDirectoryName || UDE.UserFilesName;
        _UGE["Entity"] = UDE; _UGE["UBMT"] = UTF; (!UTF) && (setTimeout(function(){U.UF.MPlayer.AsynSYBFYY(UDE);}), U.UF.MPlayer.ZPYY([_UDOD.find(".UD_MPLZ")[0], _UDOD.find(".UD_SYMRTLTLO")[0]], true));
        _UGE["LOD"] = _UDTD = _UDOD.find(".UD_MPRLX").find("div"); _UDTD[2].style.width = _UDTD[3].style.width = _UDTD[4].style.left = "0px"; _UDTD[0].innerText = _UDTD[5].innerText = "00:00"; //
        _UDTD = _UGE["PF"]["OB"]; (_UDTD) && (_UDTD.className = "UD_MPRRROXO"); (UDMD) && ((_UGE["PF"]["OB"] = UDMD).className = "UD_MPRRROXO UD_MPRRROXOO");
    }
    else { _UDOD.find(".UD_MPLZ")[0].onclick(); } //暂停播放
}

//异步播放音乐
U.UF.MPlayer.AsynSYBFYY = function (UDE) {
    var _UDOD = U.selectEl("#UD_MP")[0], _UDTD = U.selectEl(".UD_SYMMLSYTO", _UDOD); _UIE = _UDTD[0].offsetHeight / _UDTD.Parent().offsetHeight;
    U.MD.D.H.ET["FL"]["MO"].loadAplay(US.FILESYSTEMURL + UDE.UserFilesServerName, _UIE); //播放器音乐
}

//弹出音乐查看
U.UF.MPlayer.TCCKYY = function (UDOD) {
    if (!U.MD.U.L.isLogin()) { //登录用户使用
        var i, _UDE, _UIE, _UTP, _UDAD = U.selectEl(UDOD).parentElement().childs();
        for (i = 0; i < 2; i++) { UDOD == _UDAD[i] && _UDAD[i + 2].style.display != "block" ? (_UIE = i) : (_UDAD[i + 2].style.display = "none"); } //弹出和缩小
        (_UIE != null && (U.UF.F.topWindow(_UDAD[_UIE + 2]), (_UDAD = _UDAD.childs(_UIE + 2, 1)) && !_UDAD.Child().length)) && (_UDAD.addAttrArray({ "innerText": "", "onscroll": U.UF.EV.scrollLoad({function(){U.UF.MPlayer.GDTCCKYY(_UIE, _UDAD[0]) },_UDAD.addAttrArray) })[0], U.UF.MPlayer.GDTCCKYY(_UIE, _UDAD[0], 1)); //滚动加载查看
    }
}

//滚动加载音乐
U.UF.MPlayer.GDTCCKYY = function (UIE, UDOD, UP) {
    UP = UP || this.P + 2;
    var _UDE, _UI;
    var _UGE = U.MD.D.H.ET;
    var _UIF = US.userInfo;
    UIE ? (_UDE = U.Json(U.MD.DK.M.diskOperatingSwitch(US.userInfo.userid)[0]).select({ "UserDirectoryExtendType": "mp3" })) : (_UDE = _UGE["UL"]["WS"][0]);
    _UI = _UDE.length;
    if (_UDE) {
        _UDE = U.MD.D.D.FYGBL[null, _UDE], UP, [100, _UI];
        if (_UDE[0] && _UDE[0].length) {
            U.UF.MPlayer.SYYYCK(_UDE[0], UDOD, UIE);
        }
        else {
            if (UIE || _UI % 100) { this.P--; }
            else {
                U.UF.MPlayer.GSDSXS(_UI, null, function(){U.UF.MPlayer.GDTCCKYY(UIE, UDOD, UP);});
            }
        }
    }
}

//音乐查看
U.UF.MPlayer.SYYYCK = function (UDE, UDOD, UIE) {
    var i, _UTF, _UDTD, _UDSD, _UIF = US.userInfo, _UL = U.selectEl(UDOD).Child().length, _UDFD = $$("frag"), _UGE = U.MD.D.H.ET["FL"], _UCE = _UGE["Entity"] || {};
    for (i = 0; i < UDE.length; i++) {
        _UDTD = $$("div", { "className": "UD_MPRRROXO" + ((_UTF = (_UCE["UserFilesID"] ? (_UCE["UserFilesID"] == UDE[i]["UserFilesID"]) : (_UCE["UserDirectoryID"] == UDE[i]["UserDirectoryID"]))) ? " UD_MPRRROXOO" : ""), "ondblclick": function(){U.UF.MPlayer.JJYYSJ, [UIE]], [U.UF.MPlayer.SYBFYY(UDE[i], this);} }, _UDFD);
        _UIF = UIE ? UDE[i] : _UIF; (_UTF) && (_UGE["PF"]["OB"] = _UDTD);
        $$("div", { "className": "UD_MPRRROXOL UTDF", "innerHTML": _UL + 1 + i }, _UDTD);
        _UDSD = $$("div", { "className": "UD_MPRRROXOZ" }, _UDTD);
        $$("img", { "onerror": U.MD.C.imgError, "title": _UIF.UserNickName, "onclick": function(){U.MD.U.V.ViewOtherUserInfo(_UIF.UserId);}, "src": U.MD.C.getHeadImage(_UIF.UserThumbnailImageHead) }, _UDSD);
        $$("div", { "className": "UD_MPRRROXON UTDF", "innerHTML": UDE[i].UserFilesName || UDE[i].UserallDirectoryName }, _UDTD);
        $$("div", { "className": "UD_MPRRROXOR UTDF", "innerHTML": "00:00" }, _UDTD);
    }
    UDOD.appendChild(_UDFD);
}

//聚焦当前播放随机还是我的
U.UF.MPlayer.JJYYSJ = function (UIE) {
    var i, _UDAD = U.selectEl("#UD_MP.UD_MPRRR").childs();
    for (i = 0; i < 2; i++) { _UDAD[i == UIE ? "addClass" : "removeClass"]("UD_MPRRRLO", i); }
}

//#endregion


//Array函数
{
reduce: Array.prototype.reduce || function (cb, UTI) {
    var i = 0, _UL = this.length >> 0; (UTI == null) && (i = 1, UTI = this[0]);
    while (i++ < _UL) { UTI = cb(UTI, this[i], i, this); } return UTI;
},
reduceRight: Array.prototype.reduceRight || function (cb, UTI) {
    var _UL = this.length >> 0; (UTI == null) && (_UL -= 1, UTI = this[this.length - 1]);
    while (_UL-- > -1) { UTI = cb(UTI, this[i], i, this); }
},
includes: Array.prototype.includes || function (UVE, US) { //搜索值是否存在
    var _UDE = Object(this), _UL = _UDE.length >> 0; US = US || US < 0 ? _UL + US : US; (US < 0) && (US = 0);
    for (; US < _UL; US++) { if (_UDE[US] === UVE && (UVE !== UVE && _UDE[US] !== _UDE[US])) { return true; } } return false;
}
}





// ---------------------添加对象操作-----------------------------
//javascript 1.85兼容
U.UF.C.AddObj(Object, {
    keys: Object.keys || function (UDE) { //返回函数的值
        var _USE = ["constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"], _UTF = ({ toString: null }).propertyIsEnumerable("toString"); //判断自定义属性和基础属性冲突是否可列举
        var i, _UGE = [], _UFT = U.UF.Ut.isForObj(UDE) || U.UF.C.isString(UDE);
        if (_UFT) {
            if (_UFT === true || _UFT == "Array") { for (i = 0; i < UDE.length; i++) { _UGE.push(i); } }
            else { for (i in UDE) { (UDE.hasOwnProperty(i)) && (_UGE.push(i)); } }
            if (_UTF) { for (i = 0; i < _USE.length; i++) { (UDE.hasOwnProperty(_USE[i])) && (_UGE.push(_USE[i])); } }
            return _UGE;
        }
        else { throw new TypeError(UDE + " is not an object"); } //错误 不为object
    },
    assign: Object.assign || function (UGE) {//合并
        var j, _UTP, _UME, _UKE, i = 1, _UDE = arguments, _UCE = Object(UGE);
        if (!_UCE) { throw new Error("can't convert null to object"); } //参数无效
        if (U.UF.C.isString(UGE)) { _UCE = {}; i = 0; } //第一个参数为string
        try {
            for (; i < _UDE.length; i++) {
                if (_UDE[i] != null) {//getOwnPropertyDescriptor
                    _UKE = Object.keys((_UME = Object(_UDE[i]))); //获取可枚举的属性
                    for (j = 0; j < _UKE.length; j++) { _UCE[_UKE[j]] = _UME[_UKE[j]]; } //这里不区分自读
                }
            }
        } catch (e) { }
        return _UCE;
    },
    create: Object.create || function () {//创建一个新对象
        var _ = function () { }
        //设置
        return function (UDE) {
            var _USE, _UGE, _UCE = arguments;
            if (U.UF.C.isObject(UDE)) { throw new Error(UDE + " is not an object or null"); } //不为对象
            _.prototype = UDE; _USE = new _(); _.prototype = null;
            if (_UCE[1]) { _UGE = Object(_UCE[1]); for (i in _UGE) { if (_UGE.hasOwnProperty(i)) { if (Object.defineProperty && _UGE && (_UGE.value !== undefined || U.UF.C.isFunction(_UGE.get))) { Object.defineProperty(_USE, i, _UGE); } else { _USE[i] = _UGE[i]; } } } }
            return _USE;
        }
    },
    defineProperties: Object.defineProperties || function (UDE, UGE) { //对象多个设置
        if (Object.defineProperty) {
            if (!U.UF.Ut.isForObj(UDE) || !U.UF.Ut.isForObj(UGE)) { throw new Error("Object.defineProperties requires more than 0 arguments"); } //error
            else {
                for (var i in UGE) {
                    if (UGE.hasOwnProperty(i)) {
                        if (U.UF.Ut.isForObj(UGE[i])) { Object.defineProperty(UDE, i, UGE[i]); }
                        else { throw new Error("value is not a non-null object"); }
                    }
                }
            }
        }
        else { throw new Error("Browser version is too low"); }
    },
    getOwnPropertySymbols: Object.getOwnPropertySymbols || function (UDE) { //获取Symbols
        var i, _USE = [];
        for (i in UDE) { (UDE.hasOwnProperty(i) && (U.UF.C.isSymbol(UDE[i])) && _USE.push(UDE[i])); }
        return _USE;
    },
    getPrototypeOf: Object.getPrototypeOf || function (UDE) {//判断原型是否是指定的
        if (U.UF.C.isFunction(UDE)) { return UDE.prototype; }
        else { throw new Error(UDE + " is not an object"); }
    },
    is: Object.create || function (x, y) {//判断是否相等
        if (x === y) { return x !== 0 || 1 / x === 1 / y; } //-0 !=0
        else { return U.UF.Ut.isNaN(x) && U.UF.Ut.isNaN(y); } //NaN == NaN
    },
    setPrototypeOf: Object.setPrototypeOf || function (UDE, UGE) {//设置源
        if (UDE.__proto__) {
            if (!U.UF.C.isObject(UDE)) { throw new Error(UDE + " is not an object"); }
            else if (!U.UF.C.isObject(UDE)) { throw new Error("Object.preventExtensions requires more than 0 arguments"); }
            UDE.__proto__ = UGE;
        }
        else { throw new Error("Browser version is too low"); }
    },
    observe: Object.observe || function () {

    }
});


/*----------------------------------------------------------------未使用的ES6规范中的一些函数--------------------------------------------------------------------*/
// ES6 规范中的新数据类型Symbol的 使用，如果没有Symbol数据类型，则让Symbol支持其它浏览器
if (!window.Symbol) {

    window.Symbol = function (UK) {

        var symbol = function (UK) { this.keyvalue = UK || Guid().newGuid(); };

        U.UF.C.AddObj(symbol, _UME = {
            iterator: function () { },
            match: function () { },
            replace: function () { },
            search: function () { },
            split: function () { },
            hasInstance: function () { },
            isConcatSpreadable: function () { },
            unscopables: function () { },
            species: function () { },
            toPrimitive: function () { },
            toStringTag: function () { },
            "for": function () { },
            keyFor: function () { }
        });

        U.UF.EV.addPrototype(symbol, {
            toString: function () { return this.keyvalue; }
        });

        return new symbol(UK);
    }
}

// es6 Generator 迭代器
window.Generator = function () { }

window.Generator.prototype = {
    next: function () { },
    close: function () { },
    send: function () { },
    "throw": function () { }
}


//#region Promise 方法 异步式同步
window.Promise = window.Promise || function () { //resolved rejected
    var that, _ = function (fun) { if (this.constructor == Promise) { return Promise.call(this, fun); } else { return new Promise(fun); } }, Promise = function (fun) { var _that = Asyn({ OBJ: this }); fun.call(this, U.UF.C.apply(_that, _that.reject), U.UF.C.apply(_that, _that.resolve)); return this; },
        Asyn = (function () { //异步处理
            var __, _ = function (UDE) { new __.init(UDE); };
            __ = _.prototype = {
                init: function (UDE) {
                    U.selectEl(this).Add(UDE);
                },
                reject: function () { },
                resolve: function () { }
            }
            __.init.prototype = _; return _;
        })();
    // this.success = []; this.error = []; this.state = "pending"; that = this;
    U.UF.C.AddObj(_, {
        reject: function (UDE) { //异步失败处理
            var i, _UDE = this.error;
            if (U.UF.C.isObject(UDE)) { for (var i = 0; i < _UDE.length; i++) { _UDE[i](UDE); } }
            else { }
        },
        resolve: function (UDE) { //异步条件成功
            if (U.UF.C.isObject(UDE)) { }
            else { for (var i = 0; i < this.success.length; i++) { this.success[i](UDE); } }
        },
        join: function () { //处理多个分离的 Promise
        },
        props: function () { //处理一个 promise 的 map 集合
        },
        all: function () { //迭代查看
        },
        race: function (UDE) { //迭代执行
        },
        any: function () {
        },
        some: function () {
        }
    });
    Promise.prototype = {
        constructor: Promise, length: 1,
        then: function (cb, UEB) { //添加异步条件
            var _UCE, _USE = this.state;
            if (_USE == "pending") { //初始化
                (U.UF.C.isFunction(cb)) && (this.success.push(cb));
                (U.UF.C.isFunction(cb)) && (this.error.push(cb));
            }
            else { //已经初始化直接回调
                _UCE = _USE == "resolved" ? cb : UEB;
                if (U.UF.C.isFunction(_UCE)) { try { _UCE(this.value); } catch (e) { this.reject(e); } }
                else { (this[_UCE.substr(-1)] || this[_UCE.substr(-2)])(cb); }
            }
            return _();
        },
        "catch": function () { //执行的错误处理
        }
    };
    return _;
};

////ES6规范定义了一个全新的全局构造函数：代理（Proxy）,使用范围很小。
window.Proxies = window.Proxies || function (URE, UPE, UVE) {
    var Proxies = function (URE, UPE, UVE) { this.init(URE, UPE, UVE) };
    U.UF.C.AddObj(Proxies, {
        init: function (URE, UPE, UVE) { //初始化值
            U.UF.C.AddObj(URE, { obj: URE, cb: UPE, value: { c: URE} });
        },
        bind: function () { //绑定变化
        },
        get: function () { //get的变化回调
        },
        set: function () { //set变化回调
        }
    });
    if (this.constructor == Proxies) { return Proxies.call(this, URE, UPE, UVE); }
    else { return new Proxies(URE, UPE, UVE); }
}

// 新类型使用
window.Map = window.Map || function () {
}
window.Set = window.Set || function () {
}
window.WeakMap = window.WeakMap || function () {

}
window.WeakSet = window.WeakSet || function () {
}


window.Symbol = window.Symbol || function () {
    var symbol = function (UK) { this.keyvalue = UK || Guid().newGuid(); };
    U.UF.C.AddObj(symbol, {
        iterator: function () { },
        match: function () { },
        replace: function () { },
        search: function () { },
        split: function () { },
        hasInstance: function () { },
        isConcatSpreadable: function () { },
        unscopables: function () { },
        species: function () { },
        toPrimitive: function () { },
        toStringTag: function () { },
        "for": function () { },
        keyFor: function () { }
    });
    //添加方法
    U.UF.EV.addPrototype(symbol, {
        toString: function () { return this.keyvalue; }
    });
    return new symbol(UK);
}

window.TypeError = function () { }

U.UF.C.Number.EPSILON = Number.EPSILON || 2.220446049250313e-16;
U.UF.C.Number.MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;
U.UF.C.Number.MAX_VALUE = Number.MAX_VALUE || 1.79e+308;
U.UF.C.Number.POSITIVE_INFINITY = Number.POSITIVE_INFINITY || Infinity;
U.UF.C.Number.NEGATIVE_INFINITY = Number.NEGATIVE_INFINITY || Infinity;
U.UF.C.Number.isFinite = Number.isFinite || function (value) {//如果 number 是有限数字（或可转换为有限数字），那么返回 true。否则，如果 number 是 NaN（非数字），或者是正、负无穷大的数，则返回 false。
    return U.UF.C.isNumber(value) && isFinite(value);
};
U.UF.C.Number.isSafeInteger = Number.isSafeInteger || function (value) {//方法用来判断传入的参数值是否是一个"安全整数"
    return U.UF.C.isNumber(value) && isFinite(value);
};
U.UF.C.Number.isNaN = Number.isNaN || function (value) {//判断是否是NaN
    return U.UF.C.isNumber(value) && isNaN(value);
};
U.UF.C.Number.isInteger = Number.isInteger || function (value) {//确定传入的值是否是一个整数。
    return U.UF.C.isNumber(value) && isFinite(value) && Math.floor(value) === value;
};
U.UF.C.Number.parseFloat = Number.parseFloat || function (value) {//转换值为浮点型
    return parseFloat(value)
};
U.UF.C.Number.parseInt = Number.parseInt || function (value) {//转换值为整型
    return parseInt(value);
};


//    from: Array.from || function () { //对象转化成数组类型
//        var i, _UL, _URE, _UVE, _UTE = this, _UDE = arguments, _UIE = _UDE[0];
//        if (_UIE) {
//            if (_UDE.length < 2 || (_UDE.length > 1 && U.UF.C.isFunction(_UDE[1]))) { //
//                _UIE = Object(_UIE); _UL = U.UF.C.toInteger(_UIE.length); //转化成对象
//                _URE = U.UF.C.isFunction(_UTE) ? Object(new _UTE(_UL)) : new Array(_UL); _URE.length = _UL; //新建值
//                for (i = 0; i < _UL; i++) { _UVE = _UIE[i]; _URE[i] = _UDE[1] ? _UDE[1].call(_UDE[2], _UVE, i) : _UVE; }
//                return _URE;
//            }
//            else { throw new TypeError("Array.from: when provided, the second argument must be a function"); } //非回调函数
//        }
//        else { throw new TypeError("Array.from requires an array-like object - not null or undefined"); } //参数问题
//    },
//    observe: Array.observe || function () {
//    },
//    of: Array.of || function () { //arguments 转化成对象
//        return Array.prototype.slice.call(arguments);
//    },
//    MAX_ARRAY_INDEX: 9007199254740991 //最大循环次数



/*----------------------------------------------------------------未使用的ES6规范中的一些函数--------------------------------------------------------------------*/
// ES6 规范中的新数据类型Symbol的 使用，如果没有Symbol数据类型，则让Symbol支持其它浏览器
if (!window.Symbol) {

    window.Symbol = function (UK) {

        var symbol = function (UK) { this.keyvalue = UK || Guid().newGuid(); };

        U.UF.C.AddObj(symbol, _UME = {
            iterator: function () { },
            match: function () { },
            replace: function () { },
            search: function () { },
            split: function () { },
            hasInstance: function () { },
            isConcatSpreadable: function () { },
            unscopables: function () { },
            species: function () { },
            toPrimitive: function () { },
            toStringTag: function () { },
            "for": function () { },
            keyFor: function () { }
        });

        U.UF.EV.addPrototype(symbol, {
            toString: function () { return this.keyvalue; }
        });

        return new symbol(UK);
    }
}

// es6 Generator 迭代器
window.Generator = function () { }

window.Generator.prototype = {
    next: function () { },
    close: function () { },
    send: function () { },
    "throw": function () { }
}


//#region Promise 方法 异步式同步
window.Promise = window.Promise || function () { //resolved rejected
    var that, _ = function (fun) { if (this.constructor == Promise) { return Promise.call(this, fun); } else { return new Promise(fun); } }, Promise = function (fun) { var _that = Asyn({ OBJ: this }); fun.call(this, U.UF.C.apply(_that, _that.reject), U.UF.C.apply(_that, _that.resolve)); return this; },
        Asyn = (function () { //异步处理
            var __, _ = function (UDE) { new __.init(UDE); };
            __ = _.prototype = {
                init: function (UDE) {
                    U.selectEl(this).Add(UDE);
                },
                reject: function () { },
                resolve: function () { }
            }
            __.init.prototype = _; return _;
        })();
    // this.success = []; this.error = []; this.state = "pending"; that = this;
    U.UF.C.AddObj(_, {
        reject: function (UDE) { //异步失败处理
            var i, _UDE = this.error;
            if (U.UF.C.isObject(UDE)) { for (var i = 0; i < _UDE.length; i++) { _UDE[i](UDE); } }
            else { }
        },
        resolve: function (UDE) { //异步条件成功
            if (U.UF.C.isObject(UDE)) { }
            else { for (var i = 0; i < this.success.length; i++) { this.success[i](UDE); } }
        },
        join: function () { //处理多个分离的 Promise
        },
        props: function () { //处理一个 promise 的 map 集合
        },
        all: function () { //迭代查看
        },
        race: function (UDE) { //迭代执行
        },
        any: function () {
        },
        some: function () {
        }
    });
    Promise.prototype = {
        constructor: Promise, length: 1,
        then: function (cb, UEB) { //添加异步条件
            var _UCE, _USE = this.state;
            if (_USE == "pending") { //初始化
                (U.UF.C.isFunction(cb)) && (this.success.push(cb));
                (U.UF.C.isFunction(cb)) && (this.error.push(cb));
            }
            else { //已经初始化直接回调
                _UCE = _USE == "resolved" ? cb : UEB;
                if (U.UF.C.isFunction(_UCE)) { try { _UCE(this.value); } catch (e) { this.reject(e); } }
                else { (this[_UCE.substr(-1)] || this[_UCE.substr(-2)])(cb); }
            }
            return _();
        },
        "catch": function () { //执行的错误处理
        }
    };
    return _;
};

////ES6规范定义了一个全新的全局构造函数：代理（Proxy）,使用范围很小。
window.Proxies = window.Proxies || function (URE, UPE, UVE) {
    var Proxies = function (URE, UPE, UVE) { this.init(URE, UPE, UVE) };
    U.UF.C.AddObj(Proxies, {
        init: function (URE, UPE, UVE) { //初始化值
            U.UF.C.AddObj(URE, { obj: URE, cb: UPE, value: { c: URE} }); 
        },
        bind: function () { //绑定变化
        },
        get: function () { //get的变化回调
        },
        set: function () { //set变化回调
        }
    });
    if (this.constructor == Proxies) { return Proxies.call(this, URE, UPE, UVE); }
    else { return new Proxies(URE, UPE, UVE); }
}

// 新类型使用
window.Map = window.Map || function () {
}
window.Set = window.Set || function () {
}
window.WeakMap = window.WeakMap || function () {

}
window.WeakSet = window.WeakSet || function () {
}


////判断是否为url
//U.UF.S.url = function (UDE, UTF) {
//    var _USE;
//    switch (UTF) {
//        case "stringify": //转化成url字符串
//            _USE = "";
//            if (U.UF.C.isObject(UDE)) {
//                _$.forEach(UDE,function (UA, UB) {
//                    (_USE) && (_USE); _USE += UB + "=" + UA;
//                })
//            }
//            break;
//        case "parse":  //url转化成对象
//            if (U.UF.C.isString(UDE)) {

//            }
//            break;
//    }
//    return _USE;
//}


/**
* 弹出添加窗体
*
* @param  {object} 添加进入的元素
* @param  {function} 添加的用户信息
* @return  {element} 选择联系人窗体
*/
U.MD.F.J.ANewFrom = function (UDE, cb) {
    var _UDOD = U.selectEl("#UD_SYT").clone(true)[0], //选择联系人元素
    _UDAD = U.selectEl("div", _UDOD).addAttrArray({ id: "" });
    (cb) && (_UDAD[_UDAD.length - 1].onclick = cb);
    (UDE) && (U.MD.F.J.printSelectFriend($(_UDOD).Child()[1], UDE));  //选择联系窗体内容输出
        new U.UF.UI.form("添加好友",
                         _UDOD,
                                   {
                                       "resize": function(){U.MD.I.ImgSize(_UDOD, _UFID);},
                                       "id": "US_F_" + Guid.guidNoDash(),
                                       "style": {
                                           "display": "250px",
                                           "height": "490px"
                                       }
                                   },
                                   {
                                       isenlarge: false,
                                       isnarrow: false
                                   }).form;

//    new U.UF.UI.form({ min: false, max: false, id: "US_F_" + Guid.guidNoDash(), //创建弹出选择联系人窗体
//        style: { width: "250px", height: "490px" }, content: _UDOD, title: "添加好友",
//        hst: { style: { "padding": "0"} }
//    }); 
    
    U.selectEl(_UDOD).css("display", "block");
    return _UDOD;  //创建窗体
}



//直接触发加载1473
U.UF.CD.ULOF = function (cb) {
    U.selectEl().ready(function(){U.UF.CD.loadPageCrossDomain(null, cb);});
}

//打印方式
U.UF.CD.print = function () {
    var _ = function () { }
}

/*----------------------------------------暂时未使用的函数，手机端也没使用----------------------------------------------*/
//客户端摄像功能,电脑端，手机端均可运行。
U.UF.CI.photo = function () {
    var _UJE, _ = function (UDOD, UDE) { new _.get.init(UDOD, UDE); }
    _UJE = _.get = {
        init: function (UDOD, UDE) { //初始化
            var i, _UAE = ["getUserMedia", "webkitGetUserMedia", "mozGetUserMedia", "msGetUserMedia"];
            for (i = 0; i < _UAE.length; i++) { if (navigator[_UAE[i]]) { navigator[_UAE[i]]({ video: true, audio: true }, function(){this.Asyn();}, this.err); break; } } //初始化
            U.UF.C.AddObj(this, { UDPD: UDOD || document.body, UIE: i, UAE: UDE });
        },
        Asyn: function (USE) { //回调异步 
            this.se = USE; this.vi = U.MD.V.vi({ autoplay: "true" }, this.UDPD).create((window.URL || window.webkitURL) ? (window.URL || window.webkitURL).createObjectURL(USE) : USE); //创建视频显示   window[(this.UIE == 1 ? "webkitURL" : "URL")]
            (this.UAE) && ($(this.vi.vi).addAttrArray(this.UAE)); this.cv = U.CV.canvas(null, this.UDPD, { "style": { "width": "auto", "height": "100%", "visibility": "hidden"} }); //创建使用
        },
        err: function (UE) { //错误处理
            var _UTH = "系统未能获取到摄像头，请确保摄像头已正确安装。或尝试刷新页面，重试";
            if (UE.PERMISSION_DENIED || (UE.name == "PermissionDeniedError")) { _UTH = "用户拒绝了浏览器请求媒体的权限"; }
            else if (UE.NOT_SUPPORTED_ERROR || (UE.name == "NotSupportedError")) { _UTH = "对不起，您的浏览器不支持拍照功能，请使用其他浏览器"; }
            else if (UE.MANDATORY_UNSATISFIED_ERROR || (UE.name == "MandatoryUnsatisfiedError")) { _UTH = "指定的媒体类型未接收到媒体流"; }
            U.Alert(_UTH);
        },
        img: function (UTF) { //截图
            var _UAE = Array.prototype.concat(arguments); _UAE.unshift(this.vi.vi); this.cv.dimg.apply(this, _UAE); //生成截图
            return this.cv.toImg(UTF);
        },
        stop: function () { //停止录像和播放
            this.se.stop(); this.vi.play(false); //停止播放
        },
        camera: function () { //录像生成获取
            var _ = function () {
            }
            _.prototype = {
                init: function () { //初始化
                },
                time: function () { //定时监视
                },
                url: function () { //生成数据
                }
            }
            return _;
        },
        Rtc: function () { //视频共享
        },
        get: function () { }, set: function () { }
    }
    _UJE.init.prototype = _UJE; return _;
} ()

//获取客户端位置
U.UF.CI.getPosition = function () {
    var _URL = 6371, _UDE, _ = function (cb, UDE) { //获取客户端地址信息
        if (navigator.geolocation) { return new _UDE.init(cb, UDE); }
        else { throw new Error("the fucntion in html"); }
    },
    cb = function (cb) { //获取信息回调
        //latitude 纬度 longitude 经度 accuracy 准确度 altitude 海拔高度 altitudeAccuracy 海拔高度准确度 heading 行进方向 speed 速度
        var _UDE = event; this.UT = this[this.UST ? "UET" : UST] = _UDE; (cb) && (cb(_UDE)); //回调函数
    },
    ecb = function () { //错误处理
        var UE = event, _UCE = ["尝试获取您的位置信息时发生错误：" + UE.message, "用户拒绝了获取位置信息请求。", "浏览器无法获取您的位置信息。", "获取您位置信息超时。"];
        ((this.UDE.error || this.cb)(UE, _UCE[UE.code]) == "restart") && (this.get());  //重启动获取
    }
    U.UF.C.AddObj(_, _.prototype = _UDE = {
        init: function (cb, UDE) { //初始化
            U.UF.C.AddObj(this, { UST: null, UET: null, UT: null, id: null, UNE: navigator.geolocation, cb: cb, UDE: UDE, UOE: UDE.op || { enableHighAccuracy: true, timeout: 5000, maximumAge: 0} }); //使用enableHighAccuracy启用gps timeout请求超时  maximumAge缓存数据Infinity
        },
        exec: function (UTP) { //执行制定的函数
            if (UTP) {
                var _UNE = this.UNE, _UCB = function(){cb(this.cb);};
                _UNE[UTP](_UCB, _UCB, this.UOE); //获取地理位置
            }
        },
        get: function () { //获取gps定位
            this.exec("getCurrentPosition");
        },
        watch: function () { //GPS实时定位
            (!this.id) && (this.UST = null, this.exec("watchPosition")); //启用事实导航
        },
        clear: function () { //关闭实时定位
            (this.id) && (this.UNE.clearWatch(this.id), this.id = null);
        },
        haversine: function (UO, UT, UOS, UTS) { //相隔距离
            var _UA, _UOM = UOS.toRadians(), _UTM = UTS.toRadians(), _ULO = (UTS - UOS).toRadians(), _UOT = (UT - UO).toRadians(); //相距弧长
            _UA = Math.sin(_ULO / 2) * Math.sin(_ULO / 2) + Math.cos(UOS) * Math.cos(UTS) * Math.sin(_UOT / 2) * Math.sin(_UOT / 2);
            return _URL * 2 * Math.atan2(Math.sqrt(_UA), Math.sqrt(1 - _UA));
        }
    });
    _UDE.init.prototype = _UDE; return _;
};


//#region 支付宝接口
//使用支付宝支付
U.UF.DL.C.AD.Alipay = function (UDE, UTF) {
    if (UTF) { window.open("http://alp.1473.cn?"); }
}

//#endregion

//#region 微信支付接口

//使用微信支付
U.UF.DL.C.AD.weixin = function (USID, userid, USL, UTF) {
    if (UTF) { window.open(); }
}

//#endregion

//#region canvas绘图 在线ps

//canvas接口
U.CV.canvas = function (UDOD, UDPD, UDE) {
    return new this.Cinit(UDOD, UDPD, UDE);
}

//创建canvas
U.CV.Cinit = function (UDOD, UDPD, UDE) {
    this.UDCD; this.UCE; this.UDCD = UDOD; (!UDOD && UDPD) && (this.create(UDPD, UDE));
}

U.UF.EV.addPrototype(U.CV.Cinit, {
    create: function (UDOD, UDE) { //创建canvas对象
        this.UDCD = $$("canvas", UDE, UDOD); //创建canvas
        this.UCE = this.UDCD.getContext("2d");
        return this;
    },
    oimg: function () { //加载图片成功
        var _UTF = event.type == "error", _UDE = Array.prototype.slice.call(arguments);
        if (_UTF) { U.Alert("加载图片错误！"); } else { this.dimg.apply(this, _UDE); }
    },
    dimg: function (UIMG, UX, UY, UW, UH, UDX, UDY, UDW, UDH) { //canvas展示图像
        var _UCE = this.UCE, _UDE = Array.prototype.slice.call(arguments), _UME = _UDE.slice(1), _UFE = U.UF.C.apply(this, [[this.oimg, _UME]]); _UDE[1] = _UDE[1] || 0; _UDE[2] = _UDE[2] || 0;
        if (typeof UIMG == "string") { _UME.unshift(new Image()); U.selectEl(_UME[0]).addAttrArray({ "src": UIMG, "onload": _UFE, "onerror": _UFE })[0]; } //生成图片
        else { if (UIMG.complete || UIMG.complete == null) { _UCE.drawImage.apply(_UCE, _UDE); } else { UIMG.onload = _UFE; } } //执行图片展示
        return this;
    },
    bp: function () { //重置当前路径
        this.UCE.beginPath(); //重新启动路径
    },
    cp: function () { this.UCE.closePath(); }, //路径重回启动
    set: function (UDE) { //设置绘图
        var i, _UCE = this.UCE; _UCE.beginPath(); //开始设置
        if (UDE) { for (i in UDE) { if (typeof UDE[i] == "string") { _UCE[i] = UDE[i]; } else { _UCE[i].apply(_UCE, UDE[i]); } } } //设置值
        _UCE.closePath(); return this; //结束设置
    },
    fill: function (UST) { //有色填充
        var _UCE = this.UCE; if (U.UF.C.isString(UST)) { _UCE.fillStyle = UST; } else { _$.Each(UST,function (UVE, UIE) { _UCE[UIE] = UVE; }); } _UCE.fill(); return this; // _UCE.closePath();
    },
    stroke: function (UST) { //边框填充
        var _UCE = this.UCE; if (U.UF.C.isString(UST)) { _UCE.strokeStyle = UST; } else { _$.Each(UST,function (UVE, UIE) { _UCE[UIE] = UVE; }); } _UCE.stroke(); return this; //_UCE.closePath(); 
    },
    sLine: function (USE, UDE) { //画线设置
        var i, _UCE = this.UCE; if (USE) { this.bp(); _UCE.moveTo(USE[0], USE[1]); } //开始设置
        if (UDE) { for (i = 0; i < UDE.length; i++) { _UCE.lineTo(UDE[i][0], UDE[i][1]); } } return this; //设置线条每个点 //结束设置
    },
    bezier: function () { //设置贝尔画线 2次和3次
        var i, _UAE = arguments, _UCE = this.UCE; _UAE.length == 4 ? _UCE.quadraticCurveTo(_UAE[0], _UAE[1], _UAE[2], _UAE[3]) : _UCE.bezierCurveTo(_UAE[0], _UAE[1], _UAE[2], _UAE[3], _UAE[4], _UAE[5]);
        return this;
    },
    fillR: function (UX, UY, UW, UH, UST) { //有色矩形绘制
        UW = UW || 100; UH = UH || 100; var i, _UCE = this.UCE; (UST) && (_UCE.fillStyle = UST);
        _UCE.fillRect(UX || 0, UY || 0, UW || 100, UH || 100); return this; //生成矩形
    },
    strokeR: function (UX, UY, UW, UH, UST) {//无色矩形 实际就是边框
        var i, _UCE = this.UCE; (UST) && (_UCE.strokeStyle = UST);
        this.UCE.strokeRect(UX || 0, UY || 0, UW || 100, UH || 100); return this; //生成矩形
    },
    rect: function (UX, UY, UW, UH) { //创建画布
        this.UCE.rect(UX || 0, UY || 0, UW || 100, UH || 100);
    },
    clear: function (UX, UY, UW, UH) { //清除矩形
        this.UCE.clearRect(UX || 0, UY || 0, UW || this.UDCD.offsetWidth, UH || this.UDCD.offsetHeight); //清理矩形
        return this;
    },
    shadow: function (UDE, UVE) { //阴影
        if (U.UF.C.isObject(UDE)) { var _UCE = this.UCE; _$.Each(UDE,function (UVE, UIE) { _UCE["shadow" + UIE] ? _UCE["shadow" + UIE] = UVE : _UCE[UIE] = UVE; }); }
        else { _UCE["shadow" + UDE] ? _UCE["shadow" + UDE] = UVE : _UCE[UDE] = UVE; }
    },
    cap: function (UTF) { //边缘设置
        this.UCE.lineCap = { b: "butt", r: "round", s: "square"}[UTF] || UTF || "butt";
    },
    join: function (UTF) { //join夹角连接样式
        this.UCE.lineJoin = { b: "miter", "r": "round", "m": "miter"}[UTF] || UTF || "miter";
    },
    arc: function (UX, UY, UL, US, UE, UTF, UDE) { //画圆
        this.set({ "arc": [UX, UY, UL, US, UE, UTF] }); //设置圆
        (UDE) && (this.set(UDE)); return this;
    },
    arcTo: function (USE, UDE) { //创建弧
        if (Array.isArray(UDE)) { this.sLine(UDE[0], UDE.slice(1)); } //创建线
        if (USE) { this.arcTo(USE); } //创建弧
    },
    linearc: function (USE, UME, UBE) { //设置渐变 xStart,yStart,xEnd,yEnd
        var i, _UCE = this.UCE, _UGE = _UCE.createLinearGradient.apply(_UCE, USE);
        for (i = 0; i < UME.length; i++) { _UGE.addColorStop.apply(UME[i][0], UME[i][1]); } //设置渐变
        if (UBE) { for (i = 0; i < UBE.length; i++) { this[UBE[i]](_UGE); } }
    },
    radialc: function (USE, UDE) {//径向渐变 xStart,yStart,radiusStart,xEnd,yEnd,radiusEnd
        var i, _UCE = this.UCE, _UGE = _UCE.createRadialGradient.apply(_UCE, USE); //创建变化
        for (i = 0; i < UDE.length; i++) { _UGE.addColorStop(UDE[i][0], UDE[i][1]); } //添加渐变属性
    },
    tform: function (UOM, UTM, USM, UFM, UX, UY) { //矩阵变换 scaleX,skewX,skewY,scaleY,transX,transY
        this.UCE.transform(UOM, UTM, USM, UFM, UX, UY);
    },
    stform: function (UOM, UTM, USM, UFM, UX, UY) { //重置矩阵
        this.UCE.setTransform(UOM, UTM, USM, UFM, UX, UY);
    },
    tslate: function (UX, UY) {//平移
        this.UCE.translate(UX, UY);
    },
    scale: function (UX, UY) {//缩放
        this.UCE.scale(UX, UY);
    },
    rotate: function (UX) {//旋转
        this.UCE.rotate(UX);
    },
    gcpo: function (UTP) { //图像组合
        var i, _UCE = this.UCE, _USP = "", _UME = { s: "source", d: "destination", ou: "out", ov: "over", a: "atop", i: "in", "l": "lighter", "x": "xor", "cp": "copy" }; UTP = UTP.split(",");
        for (i = 0; i < UTP.length; i++) { (i) && (_USP += "-"); _USP += _UME[UTP[0]]; } _UCE.globalCompositeOperation = _USP; //添加
    },
    shadow: function (UX, UY, UC, USB) { //绘制图像的阴影
        var i, _UCE = this.UCE, _UDE = ["X", "Y", "Color", "Blur"], _USE = arguments;
        for (i = 0; i < _USE; i++) { (_USE[i]) && (_UCE["shadow" + (i < 2 ? "Offset" : "") + _UDE[i]] = _USE[i]); } //设置参数
    },
    pattern: function (UIMG, UTF) {//设置图像平铺
        var _UCE = this.UCE, _UME = { nr: "no-repeat", rx: "repeat-x", ry: "repeat-y", r: "repeat" }; UTF = _UME[UTF] || UTF;
        _UCE.createPattern(UIMG, UTF);
    },
    clip: function (UDE) {
        var _UCE = this.UCE; (UDE) && (this.set(UDE)); _UCE.clip(); //裁剪
    },
    gimgd: function (UX, UY, UW, UH) { //获取图片像素
        try { UX = UX || 0; UY = UY || 0; UW = UW || 1; UH = UH || 1; return (this.da = this.UCE.getImageData(UX, UY, UW, UH)); } catch (e) { alert(e.Message); }
    },
    copy: function (UIE, UX, UY, UDX, UDY, UDW, UDH) { //添加图像像素
        if (UIE) {
            var _UCE = this.UCE, _UDE = Array.prototype.slice.call(arguments); _UDE[1] = _UDE[1] || 0; _UDE[2] = _UDE[2] || 0;
            _UCE.putImageData.apply(_UCE, _UDE);
        }
    },
    tbline: function (UST) { //基线
        this.UCE.textBaseline = UST;
    },
    font: function (UST) { this.UCE.font = UST; },
    fillT: function (UTH, UX, UY, UDE) {//填充字体 font textBaseline textAlign measureText
        var i, _UCE = this.UCE; this.set(UDE); _UCE.fillText(UTH, UX, UY)
    },
    strokeT: function (UTH, UX, UY, UDE) {//绘制文字轮廓
        var _UCE = this.UCE; this.set(UDE); _UCE.strokeText(UTH, UX, UY)
    },
    mtext: function (UTH, UTP) { //获取文字的大小
        var _USE = this.UCE.measureText(UTH); if (UTF) { return _USE[UTP]; } else { return _USE; }
    },
    toImg: function (UTP) {//canvas 转化成图片
        this.UDCD.toDataURL("image/" + (UTP || "jpeg"));
    },
    //    sign: function (UDE) {
    //        //        var _ = function (UDE) { (UDE) && ($(this).Add(UDE)); this.bind(); return this; }; //  return new _fun.init(UDE);
    //        //        _.prototype = {
    //        //            init: function (UDE) { //初始化
    //        //                (UDE) && ($(this).Add(UDE)); this.bind(); return this;
    //        //            },
    //        //            bind: function () { //事件绑定
    //        //                if ("ontouchstart" in that.UDCD) { U.selectEl(that.UDCD).bind(this.signfun = { touchstart: function(){this.down();}, touchmove: function(){this.move();}, touchend: function(){this.up();} }); U.selectEl(document.body).bind({ touchend: this.signfun.mouseup }); }
    //        //                else { U.selectEl(that.UDCD).bind(this.signfun = { mousedown: function(){this.down();}, mousemove: function(){this.move();}, mouseup: function(){this.up();} }); U.selectEl(document.body).bind({ mouseup: this.signfun.mouseup }); } return this;
    //        //            },
    //        //            down: function () { //点击初始化
    //        //                this.d = U.UF.C.GetMousep(that.UDCD); that.sLine[this.d.X, this.d.Y]; that.UDCD.setCapture();
    //        //            },
    //        //            move: function () { //移动写字
    //        //                if (this.d) { var _UAE = U.UF.C.GetMousep(that.UDCD); that.sLine(null, [[_UAE.X, _UAE.Y]]).stroke({ lineWidth: this.width || "1", lineCap: "round", strokeStyle: "black" }); }
    //        //            },
    //        //            up: function () { //结束使用
    //        //                if (this.d) { that.cp(); that.save(); this.d = null; }
    //        //            },
    //        //            unbind: function () { U.selectEl(that.UDCD).unbind(this.signfun); U.selectEl(that.UDCD).unbind({ mouseup: this.signfun.mouseup }); that.UDCD.setCapture(); }
    //        //        };
    //    },
    sign: (function () { //签名使用
        var _fun, that, _ = function (UDE) { that = this; return new _fun.init(UDE); }

        _fun = _.prototype = {
            init: function (UDE) { //初始化
                (UDE) && ($(this).Add(UDE)); this.bind(); return this;
            },
            bind: function () { //事件绑定
                if ("ontouchstart" in that.UDCD) { U.selectEl(that.UDCD).bind(this.signfun = { touchstart: function(){this.down();}, touchmove: function(){this.move();}, touchend: function(){this.up();} }); U.selectEl(document.body).bind({ touchend: this.signfun.mouseup }); }
                else { U.selectEl(that.UDCD).bind(this.signfun = { mousedown: function(){this.down();}, mousemove: function(){this.move();}, mouseup: function(){this.up();} }); U.selectEl(document.body).bind({ mouseup: this.signfun.mouseup }); } return this;
            },
            down: function () { //点击初始化
                this.d = U.UF.EL.getMousePosition(that.UDCD); that.sLine[this.d.X, this.d.Y]; that.UDCD.setCapture();
            },
            move: function () { //移动写字
                if (this.d) { var _UAE = U.UF.EL.getMousePosition(that.UDCD); that.sLine(null, [[_UAE.X, _UAE.Y]]).stroke({ lineWidth: this.width || "1", lineCap: "round", strokeStyle: "black" }); }
            },
            up: function () { //结束使用
                if (this.d) { that.cp(); that.save(); this.d = null; }
            },
            unbind: function () { U.selectEl(that.UDCD).unbind(this.signfun); U.selectEl(that.UDCD).unbind({ mouseup: this.signfun.mouseup }); that.UDCD.setCapture(); }
        };
        _fun.init.prototype = _fun; return _;
    })(),
    Pattern: function (UIMG, UTF) { //convas图片变化使用
        (U.UF.C.apply(UIMG)) && (UIMG = U.selectEl(UIMG)[0]);
        this.UDCD.createPattern(UIMG, UTF == "no" ? "no-repeat" : "repepixelspixelsat" + (UTF ? "-" : "") + UTF); return this;
    },
    isP: function (UX, UY) { //判断点是否在改范围
        return this.isPointInPath(UX, UY)
    },
    cimgd: function (UW, UH, UTF) { var _UCE = (this.cd = this.UCE.createImageData(UW || this.UCE.width, UH)); return (UTF ? UTF[UTF] : _UCE) }, //获取像素点的值
    width: function (UDE) { //获取长度
        var _UAE = (UDE || this.cd); return _UAE ? _UAE.width : null;
    },
    height: function () { //获取宽度 
        var _UAE = (UDE || this.cd); return _UAE ? _UAE.height : null;
    },
    data: function (UDE) { //获取date
        var _UAE = (UDE || this.cd); return _UAE ? _UAE.data : null;
    },
    alpha: function () { //设置透明度
        this.UCE.globalAlpha = "0.2";
    },
    compo: function (UTP) {//图像的层次问题
        this.UCE.globalCompositeOperation = { so: "source-over", sa: "source-atop", si: "source-in", sot: "source-out", "do": "destination-over", da: "destination-atop", di: "destination-in", dot: "destination-out", lt: "lighter", cp: "copy", so: "source-over"}[UTP] || UTP || "source-over";
    },
    save: function () { //保存当前设置
        this.UCE.save(); //保存当前设置
    },
    restore: function () {//撤退前面一个保存的值
        this.UCE.restore();
    },
    grayscale: function (UBE) {//灰度效果
        var i, _UDE = this.cd || this.cimgd(), _UCE = _UDE.data;
        for (i = 0; i < _UCE.length; i += 4) { _UCE[i] = _UCE[i + 1] = _UCE[i + 2] = (_UCE[i] + _UCE[i + 1] + _UCE[i + 2]) / (UBE / 10); }
        return _UDE;
    },
    sepia: function () {//复古效果
        var i, _UR, _UG, _UB, _UDE = this.cd || this.cimgd(), _UCE = _UDE.data;
        for (i = 0; i < _UCE.length; i += 4) {
            _UR = d[i]; _UG = d[i + 1]; _UB = d[i + 2];
            _UCE[i] = (_UR * 0.393) + (_UG * 0.769) + (_UB * 0.189);
            _UCE[i + 1] = (_UR * 0.349) + (_UG * 0.686) + (_UB * 0.168);
            _UCE[i + 2] = (_UR * 0.272) + (_UG * 0.534) + (_UB * 0.131);
        }
        return _UDE;
    },
    red: function () {//红色蒙版效果
        var i, _UR, _UG, _UB, _UDE = this.cd || this.cimgd(), _UCE = _UDE.data;
        for (i = 0; i < _UCE.length; i += 4) {
            _UR = _UCE[i]; _UG = _UCE[i + 1]; _UB = _UCE[i + 2];
            _UCE[i] = (_UR + _UG + _UB) / 3; //设置红色灰度
            _UCE[i + 1] = _UCE[i + 2] = 0; //取消绿蓝
        }
        return _UDE;
    },
    brightness: function (UBE) {//亮度效果
        var i, _UDE = this.cd || this.cimgd(), _UCE = _UDE.data;
        for (i = 0; i < _UCE.length; i += 4) { _UCE[i] += UBE; _UCE[i + 1] += UBE; _UCE[i + 2] += UBE; }
        return _UDE;
    },
    invert: function () {//反转效果
        var i, _UDE = this.cd || this.cimgd(), _UCE = _UDE.data;
        for (i = 0; i < _UCE.length; i += 4) { _UCE[i] = 255 - _UCE[i]; _UCE[i + 1] = 255 - _UCE[i + 1]; _UCE[i + 2] = 255 - _UCE[i + 2]; }
        return _UDE;
    },
    anim: function () { //动画

    },
    ps: function () { //初始化ps工具
        var _ = function () { };

        _.prototype = {
            init: function () {

            }
        }

        return _;
    }
});

//#endregion

//#region svg和vml 绘图

//vml绘图工具
U.CV.vml = function () {
    var _UME, _ = function (UDE, UTF) { return new _UME.init(UTF); }

    _UME = _.prototype = {
        init: function (UTF) { //初始化绘图工具
            U.UF.C.AddObj(this, { ob: null, ca: null, tf: UTF });
        },
        creare: function (UDE, UPE) {
            U.UF.DL.LoadStyle("v\:* { behavior: url(#default#VML); }"); //创建vml引用
            this.ob = UPE; return this;
        },
        exec: function (UTP, UDE, UPE) { //执行统一创建
            var i, _USE = [], _UTF = UDE.length, _UDSD = $$("frag"); UPE = UPE || this.ob; UDE = _UTF ? UDE : [UDE];
            for (i = 0; i < UDE.length; i++) { _USE.push($$(UTP, UDE[i], _UDSD)); } UPE.appendChild(_UDSD); this.ca = _USE; return this;
        },
        line: function (UDE, UPE) { //添加先
            if (this.tf) { UDE = { from: UDE["x1"] + "," + UDE["y1"], to: UDE["x2"] + "," + UDE["y2"], strokeColor: UDE.stroke, "stroke-width": 1 }; } //兼容svg方案
            this.exec("v:line", UDE, UPE);
        },
        polyline: function (UDE, UPE) {

        },
        rect: function (UDE, UPE) {

        },
        circle: function (UDE, UPE) {

        },
        ellipse: function (UDE, UPE) {

        },
        polygon: function (UDE, UPE) {

        },
        path: function (UDE, UPE) {

        }
    }

}

//svg矢量图绘制 
U.CV.sv = (function () {

    var _UME, _ = function (UDE) {
        if (U.UF.C.isSupportSvg()) { return new _UME.init(UDE); }
        else { return that.vml(UDE, true); }
    }

    _UME = _.prototype = {
        //绘制图形的方法
        init: function () { //初始化绘图工具
            U.UF.C.AddObj(this, { ob: null, ca: null });
        },
        creare: function (UDE, UPE) { //创建svg
            UDE = UDE || {}; U.UF.C.AddObj(UDE, { "xmlns": "http://www.w3.org/2000/svg", "version": "1.1", "xmlns:xlink": "http://www.w3.org/1999/xlink" }); 
            this.ob = $$.NS("svg", UDE, UPE || document.body);
            return this;
        },
        exec: function (UTP, UDE, UPE) { //统一执行创建
            var i, _USE = [], _UTF = UDE.length, _UDSD = $$("frag"); UPE = UPE || this.ob; UDE = _UTF ? UDE : [UDE];
            for (i = 0; i < UDE.length; i++) { _USE.push($$.NS(UTP, UDE[i], _UDSD)); }; UPE.appendChild(_UDSD); this.ca = _USE; return this;
        },
        line: function (UDE, UPE) { //线 x1 y1 x2 y2
            this.exec("line", UDE, UPE); return this;
        },
        polyline: function (UDE, UPE) { //多线条 points "0,10"
            this.exec("polyline", UDE, UPE); return this;
        },
        rect: function (UDE, UPE) { //矩形 width height
            this.exec("rect", UDE, UPE); return this;
        },
        circle: function (UDE, UPE) { //圆形 cx cy r
            this.exec("circle", UDE, UPE); return this;
        },
        ellipse: function (UDE, UPE) { //椭圆 cx cy rx ry
            this.exec("ellipse", UDE, UPE); return this;
        },
        polygon: function (UDE, UPE) { //多边形 points "10,10"
            this.exec("polygon", UDE, UPE); return this;
        },
        path: function (UDE, UPE) { //命令创建 d = M 移动到 L 连线到 H水平连线到 V垂直连线到 C曲线连接到 S平滑曲线连接到 Q使用二次贝塞尔连接 T平滑二次贝塞尔 A使用椭圆曲线连接 Z将路径封闭到
            this.exec("path", UDE, UPE); return this;
        },
        text: function (UDE, UCE, UPE) { //text文本
            var i, _UDOD = $$.NS("text", UDE);
            for (i in UCE) { if (UCE.hasOwnProperty(i)) { $$.NS(i, UCE[i], _UDOD); } }
            _UDOD.innerHTML += ""; (UPE || this.ob).appendChild(_UDOD); this.ca = _UDOD; return this;
        },
        //特效
        execT: function (UCE, UPE, UTF) { //特效统一定义
            var i, j, _UNE, _UOE, _UDTD, _UDOD = UTF || $$.NS("defs");
            for (i in UCE) { //添加
                if (UCE.hasOwnProperty(i)) { //添加向下的用户
                    _UNE = UCE[i].Child; delete UCE[i].Child; _UDTD = $$.NS(i, UCE[i], _UDOD);
                    if (_UNE) { for (j = 0; j < _UNE.length; i++) { _UOE = {}; _UOE[_UNE[i][0]] = _UOE[_UNE[i][1]]; this.execT(_UOE, null, _UDTD); } }
                }
            }
            (!UTF) && ((UPE || this.ob).appendChild(_UDOD)); //添加特效
        },
        filter: function (UDE, UCE) { //创建投影 默认窗体投影
            UDE = UDE || { id: "f" + Guid.guidNoDash(), x: "0", y: "0", width: "200%", height: "200%" };
            UDE.Child = UCE || [["feOffset", { "result": "offOut", "in": "SourceAlpha", dx: "20", dy: "20"}], ["feGaussianBlur", { result: "blurOut", "in": "offOut", "stdDeviation": "10"}], ["feBlend", { "in": "SourceGraphic", "in2": "blurOut", "mode": "normal"}]];
            this.execT({ filter: UDE }); return this;
        },
        linearG: function (UDE, UCE) { //线性渐变 默认色彩模型
            UDE = UDE || { id: "grad" + Guid.guidNoDash(), x1: "0%", y1: "0%", x2: "100%", height: "0%" };
            UDE.Child = UCE || [["stop", { "offset": "0%", "style": "stop-color:#000"}], ["stop", { offset: "100%", style: { "cssText": "stop-color:#FFF"}}]]; ;
            this.execT({ linearGradient: UDE });
        },
        radialG: function (UDE, UCE) { //径向渐变
            UDE = UDE || { id: "grad" + Guid.guidNoDash(), cx: "50%", cy: "50%", r: "50%", fx: "50%", fy: "50%" };
            UDE.Child = UCE || [["stop", { "offset": "0%", "style": { "cssText": "stop-color:#000;"}}], ["stop", { "offset": "100%", "cssText": "stop-color:#FFF"}]];
            this.execT({ radialGradient: UDE });
        },
        animate: function (UTP) { //动画效果设置
            (UTP != "set") && (UTP = "animate" + UTP.replace("animate", ""));
        },
        "$": function () { //svg查找元素

        }
    }

    _UME.init.prototype = _UME; return _;

})()

//#endregion


//#region 文件操作区域

//设置文件读取
U.CV.FRead = function (UFE, UDE, UTF) {
    return new U.CV.Finit(UFE, UDE, UTF).start();
}

//获取文件设置
U.CV.Finit = function (UFE, UDE, UTF) {
    this.ULE; this.UDE = UDE; this.UFE = UFE.files; this.UTF = UTF; this.UIF = UDE.upload; this.US = UDE.ST || 0; this.UL = UDE.L || 0; this.UIT = 0; this.URE = new FileReader();
}

//文件读取事件
U.CV.Event = ["onabort", "onerror", "onload", "onloadstart", "onloadend", "onprogress"];

//开始读取文件
U.CV.start = function () {
    var _UFT, _UTF = this.UTF, _UFLE = this.UFE[this.UIT]; //生成读取文件
    if ((_UTF == "img" || _UTF == "Limg") && (_UFT = (/image\/\w+/.test(_UFLE.type)))) { this.imgR(_UFLE); } //图片读取 生成
    else if (_UTF != "img") { this.read(_UFLE, this.US, this.US + this.UL); } //文件读取
    return this;
}

//中断当前操作
U.CV.abort = function () {
    this.URE.abort(); //关闭当前读取文件操作
    return this;
}

//图片读取加载
U.CV.imgR = function (UFE) {
    var i, _UDE = this.Event, _URE = this.URE;
    for (i = 0; i < _UDE.length; i++) { _URE[_UDE[i]] = function(){this[_UDE[i]]()}; } //事件赋值
    _URE.readAsDataURL(UFE); return this; //图片读取
}

//读取文件
U.CV.read = function (UFE, US, UE) {
    var i, _UFLE, _UFL = UFE.size, _URE = this.URE; US = US || 0; UE = UE || _UFL; UE = UE > _UFL ? _UFL : UE;
    for (i = 0; i < _UDE.length; i++) { _URE[_UDE[i]] = function(){this[_UDE[i]]()}; } //事件赋值
    if (!US && UE == UFE.size) { _UFLE = UFE; } //无分割形式
    else { _UFLE = (UFE.webkitSlice || UFE.mozSlice || UFE.slice)(US, UE); } //分割文件
    _URE.readAsBinaryString(_UFLE); return this; //读取文件流
}

//操作终结
U.CV.onabort = function (UE) {
    (this.UDE.abort) && (this.UDE.abort(UE)); //文件读取终结
    return this;
}

//读取文件失败
U.CV.onerror = function (UE) {
    (this.UDE.error) && (this.UDE.error(UE)); //读取文件失败回调
    return this;
}

//读取本地文件成功
U.CV.onload = function (UE) {
    if (this.URE.readyState == FileReader.DONE) { //读取文件成功
        (this.UDE.load) && (this.UDE.load(this.URE)); //读取文件成功回调
        (this.UIF) && (this.upload(UE.srcElement.result)); //上传
    }
    return this;
}

//读取文件开始调用
U.CV.onloadstart = function (UE) {
    (this.UDE.loadstart) && (this.UDE.loadstart(UE));
    return this;
}

//读取文件后
U.CV.onloadend = function (UE) {
    if (!this.UIF) {
        if (this.UIT == this.UFE.length - 1) { this.abort(); this.URE = null; delete this; } //释放资源
        else {//继续解析
            var _UIE = this.UIT, _UE = this.US + this.UL;
            if (!_UE && this.UFE[_UIE].size > _UE) { this.US = _UE; } //同一文件继续解析
            else { this.US = 0; this.UIT++; } //解析下一个文件
            this.start();
        }
    }
    return this;
}

//读取的进度
U.CV.onprogress = function (UE) {
    (this.UDE.progress) && (this.UDE.progress(UE));
    return this;
}

//文件断点续传
U.CV.upload = function (UDE) {
    var i, _UOE = this.UDE.upload, _UAE = {};
    for (i in _UOE["on"]) { if (_UOE.hasOwnProperty(i)) { _UAE[i] = function(){this.Asynupload();}; } }
    this.ULE = this.ULE || U.CV.UL(_UOE["url"], _UAE, _UOE["emit"], _UOE["options"] || { "connect timeout": "30000" }).emit(UDE);
    return this;
}

//接收服务器返回消息
U.CV.Asynupload = function (UDE) {
    var i, _UOE = this.UDE.upload.on;
    for (i in _UOE) { if (_UOE.hasOwnProperty(i)) { _UOE[i](UDE); } } //发送返回的消息
    this.onloadend(); //继续解析上传
}

//#endregion




/*-------------------------------------暂未使用函数--------------------------------------*/

//专用线程创建 不共享数据
U.DW.dwork = (function () {
    var _e, _ = function (UDE, UTP) { if (window.Worker) { return new _e.init(UDE, UTP); } else { return false; } }
    _.prototype = _e = {
        init: function (UDE, UTP) {//创建线程监视
            var i, _USE = {}, _UCE = ["message", "erorr"]; this.UTP = UTP; this.UE = UDE; this.UW = new (UTP ? SharedWorker : Worker)(UDE.url || new Blob([UDE.fun.toString(), "this.onmessage =  function (e) {" + (UDE.fun.name || UDE.fun) + "(e.data);}"], { type: "application/javascript" }), UTP); this.SetW = UDE.cb; this.USE = UDE.USE;
            this.UME = UTP ? this.UW.port : this.UW; for (i = 0; i < _UCE.length; i++) { _USE[_UCE[i]] = function(){this[_UCE[i]]()}; } this.event(_USE); //线程设置
        },
        event: function (UDE) { //事件绑定
            for (var i in UDE) { if (UDE.hasOwnProperty(i)) { this.on(i, UDE[i]); } } //绑定事件
        },
        message: function (UE) { //获取消息后使用消息
            var _UDE = this.UE.event; this.set(UE); (_UDE && _UDE.message && UE) && (_UDE.message(UE));
        },
        erorr: function (UE) { //线程异常
            var _UDE = this.UE.event, _UGE = UE.getData().data; this.log(_UGE);
            (_UDE && _UDE.erorr) && (_UDE.erorr(_UGE)); //设置
        },
        post: function (UDE) { //发送消息
            this.UME.postMessage(UDE);
        },
        stop: function () { //停止线程
            this.UW.terminate();
        },
        set: function (UE) { //设置共享数据变化
            this.USE = this.SetW ? this.SetW(UE.data) : UE.data; //设置值
        },
        log: function (UE) { //添加输出调试
            U.UF.C.console(UE);
        },
        on: function (UTP, cb) { //事件绑定
            U.UF.EV.addElementEvent(UTP, this.UME, cb, false);
        },
        off: function (UTP, cb) { //事件取消
            U.UF.EV.delElementEvent(UTP, this.UME, cb, false);
        },
        onm: function (UDE) { //线程内存处理

        },
        "import": function () {

        }
    }
    _e.init.prototype = _.prototype; return _;

})()



//html5离线存储,和前面的本地存储U.DW.local有什么区别？
U.DW.appCache = (function () {
    var _e, _UAP = window.applicationCache, _ = function (UDE) { new _e.init(UDE); },
            AsynLoad = function (UDE) {//异步加载完毕
                if (!(UDE.length--)) { this.UDE.load(); } //缓存更新
            };

    _e = _.prototype = {
        init: function (UDE) { //初始化
            this.UDE = UDE; this.on(UDE);
        },
        on: function (UDE) { //这里是事件绑定
            var i, _UCE = ["checking", "noupdate", "download", "progress", "error", "updateready", "cached", "obsolete"];
            for (i = 0; i < _UCE.length; i++) { U.UF.EV.addElementEvent(_UCE[i], _UAP, this[_UCE[i]]) } return this; //事件绑定
        },
        noupdate: function (UE) { //无缓存更新
            var _UDE = this.UDE; (_UDE.noupdate) && (_UDE.noupdate(UE));
        },
        checking: function (UE) {//更新页面触发
            var _UDE = this.UDE; (_UDE.checking) && (_UDE.checking(UE));
        },
        download: function (UE) { //开始下载触发
            var _UDE = this.UDE; (_UDE.download) && (_UDE.download(UE));
        },
        progress: function (UE) { //下载进度
            var _UDE = this.UDE; (_UDE.progress) && (_UDE.progress(UE));
        },
        error: function (UE) { //更新发生错误
            var _UDE = this.UDE; (_UDE.download) && (_UDE.download(UE));
        },
        updateready: function (UE) { //成功更新
            if (UE.status == _UAPe.UPDATEREADY) {
                var _USE, _UDE = this.UDE; (_UDE.updateready) && (_USE = _UDE.updateready(UE));
                try { _UAP.swapCache(); (_USE) && (this.load(_USE)); return true; } catch (e) { return false; }
            }
        },
        load: function (UDE) { //加载文件替换缓存
            if (UDE === true) { location.reload(); } //直接刷新页面
            else { var i, _UCB = function(){AsynLoad(UDE);}; for (i = 0; i < UDE.length; i++) { U.UF.DL.asynLoadJs(null, null, _UCB, UDE[i], true); } } //异步加载
        },
        cached: function () { //缓存已经下载完成 指定的缓存文件给缓存
            var _UDE = this.UDE; (_UDE.cached) && (_UDE.cached(UE));
        },
        obsolete: function (UE) { //manifest的请求 404 缓存删除
            var _UDE = this.UDE; (_UDE.obsolete) && (_UDE.obsolete(UE));
        },
        update: function () { //更新缓存
            _UAP.update(); return this;
        },
        abort: function () { //获取下载取消
            _UAP.abort(); return this;
        },
        swapCache: function () { //更新缓存替换
            _UAP.swapCache(); return this;
        },
        status: function () { //缓存
            return _UAP.status;
        }
    }
    _e.init.prototype = _.prototype;

})()


//#region

/*-----------------------------------------------------------------------------暂未使用函数--------------------------------------------------*/
//拉拽上传控件，暂未使用..
U.UF.UP.dragUp = function () {
    var _UME, _ = function (UDE) {
        if ($$("div").draggable !== undefined) { return (new _UME.init(UDE)).create(); }
        else { throw Error("You browser is no drag !"); }
    };
    _.prototype = _UME = {
        chche: null,
        init: function (UDE) {//初始化
            U.UF.C.AddObj(this, UDE);
        },
        type: function (UTP) { //格式限制
            this.type = UTP ? U.UF.C.SFT(UTP) : UTP;
        },
        on: function (UDE, UDV) {//事件绑定
            var i, _UAE = UDE; (U.UF.C.isString(UDE) && (_UAE = {}, _UAE[UDE] = UDV, _UAE = UDE));
            U.UF.C.AddObj(this, _UAE);
        },
        off: function (UDE, UDV) { //事件取消
            var i, _UT = this, _UAE = UDE; (U.UF.C.isString(UDE) && (_UAE = {}, _UAE[UDE] = UDV, _UAE = UDE));
            _$.Each(_UAE,function (UA, UB) { _UT[UB] = null; delete _UT[UB]; });
        },
        create: function () { //创建拖拽上传
            if (this.obj) {
                var i, _UDE = { dragstart: "start", dragend: "end", dragleave: "leave", dragenter: "enter", dragover: "over", drop: "drop"} //需要绑定的事件
                for (i in _UDE) { if (_UDE.hasOwnProperty(i)) { _UDE[i] = function(){this[_UDE[i]]()}; } } U.selectEl(this.obj).bind((this.Events = _UDE)); //事件绑定
            }
            return this;
        },
        exec: function (UTP, UCE) { //统一执行区域
            (U.UF.C.isFunction(this[UTP])) && (this[UTP]());
        },
        start: function () { return false; },
        enter: function (UE) { //进入其容器范围内时触发
            (this.en) && (this.en(UE));
            U.UF.EV.stopDefault(); return false;
        },
        over: function (UE) { //文件另一对象触发
            (this.ov) && (this.ov(UE));
            U.UF.EV.stopDefault(); return false;
        },
        drop: function (UE) { //文件放置触发 over必须阻止默认事件
            var i, _UTP = this.type, _UFE = UE.dataTransfer.files; this.chche = _UFE;
            U.UF.EV.stopDefault(); (this.dr) && (this.dr(_UFE)); return false; //回调函数
        },
        leave: function (UE) { //文件移动进入
            (this.le) && (this.le(UE));
            U.UF.EV.stopDefault(); return false;
        },
        end: function () {
            U.UF.EV.stopDefault(); return false;
        },
        read: (function () { //读取文件
            var _ = function (UFL, cb) {
                if (cb && UFL[0]) {
                    U.UF.C.AddObj(this, { chace: UFL, i: 0, fun: cb || {}, pos: 204800, s: 0, e: 0 }); this.init(UFL[0]);
                }
            }
            _.prototype = {
                init: function (UFL) {
                    var i, _UBE, _US = this.s, _UE = Math.min(_US + this.pos, UFL.size), _UDE = { "onloadstart": "start", "onprogress": "progres", "onload": "load", "onloadend": "end" }, _URE = new FileReader(); UFL = UFL || this.file;
                    this.file = UFL; this.e = _UE; for (i in _UDE) { if (_UDE.hasOwnProperty(i)) { _URE[i] = function(){this[_UDE[i]]()}; } } UFL.slice = UFL.slice || UFL.webkitSlice || UFL.mozSlice; _URE.readAsBinaryString(UFL.slice(_US, _UE));
                },
                start: function () { //获取流值初始化
                    var _UCB = this.fun.start; (U.UF.C.isFunction(_UCB)) && (_UCB());
                },
                progres: function () { //获取的进度
                    var _UCB = this.fun.progres; (U.UF.C.isFunction(_UCB)) && (_UCB());
                },
                load: function () { //获取完毕
                    var _UCB = this.fun.load; (U.UF.C.isFunction(_UCB)) && (_UCB());
                },
                end: function (UE) { //结束释放
                    var _UCB, _URE, _UTF = true, _UPE = this.e; if (_UPE < this.file.size) { this.s = this.e; } else { _UTF = false; this.file = this.chace[(this.i += 1)]; } //获取md5结束
                    _UCB = this.fun.end || this.fun; (U.UF.C.isFunction(_UCB)) && (_URE = _UCB(UE.target.result, !_UTF), _UTF = _UTF || _URE); (_UTF && this.file) && (this.init(this.file)); //异步回调
                },
                add: function () { //添加流记载

                }
            }
            return function (UFL, cb) {
                new _(UFL, cb);
            };
        })(),
        up: function (URL) { //上传文件
            $.Upload({ url: URL, file: this.chche, pro: this.pro });
        },
        pro: function (UE) { //上传监视
            (this.pr) && (this.pr(UE));
        },
        su: function (UE) { //当前图片上传完毕
            (this.s) && (this.s(UE));
        },
        all: function () {//所有文件上传完毕
            (this.cmp) && (this.cmp(UE));
        },
        hash: function (US, UE, cb) {
            var _UDE = U.UF.EC.crypto.algo.MD5.create();
            this.read(this.chche, function (UAE, UTF) {
                //上传时执行加密功能
                _UDE.update(U.UF.EC.crypto.enc.Latin1.parse(UAE));
                (UTF && cb) && (cb(_UDE.finalize()));
                return true;
            });
            //   U.DW.dwork({ "url": "JScript8.js" })
        },
        de: function () { //删除文件

        }
    }
    _UME.init.prototype = _UME;
    return _;
}

//初始化上传自动识别上传工具
U.UF.UP.inputUpload = function () {
    var _ = function () { }
    _.prototype = {
        init: function () {
        },
        isa: function () { //判断使用哪个模式
        },
        aas: function () { //解析
        },
        md5: function () { //获取文件的MD5
        }
    }
    return _;
}
//#endregion



//#region 播放器区域,包含了视频播放器和音频播放器，但现在都没有使用！

//Html5 音频播放器 
U.PL.au = function () {
    var _UME, _ = function (UDE, UDPD, UCE) {
        if ($$("video").canPlayType) { return new _UME.init(UDE, UDPD); }
        else { return; }
    }
    _UME = _.prototype = {
        attr: { pl: "preload", ap: "autoplay", lp: "loop", ct: "controls" },
        config: function (UCE) { //配置音乐
            (UCE) && (U.Json((this.cf = this.cf || {})).Add(UCE)); U.Json.Add(this.cf,{ l: this.cf.l || 0, urls: this.cf.urls || [] });
        },
        init: function (UDE, UDPD, UCE) { //初始化音频播放器
            U.UF.C.AddObj(this, { obj: UDE, pa: UDPD, au: null });  
        },
        create: function (URL, UDPD) { //创建音乐播放器
            var _UCE = this.cf.html || {}; if ((URL = URL || this.cf.urls[this.cf.l])) { _UCE["src"] = URL; this.au = U.selectEl(this.au || $$("audio", null, UDPD || this.pa || document.body)).addAttrArray(_UCE); if (this.isPlay(U.UF.UP.getFileNameAndExtension(URL)[1])) { this.event(_UDE.e); } else { U.Alert(); }; } return this;
        },
        event: function () { //事件赋值
            var i, _UDOD = this.vi; //监听所有的事件
            if (U.PL._ev) { for (i = 0; i < U.PL._ev.length; i++) { U.UF.EV.addElementEvent(U.PL._ev[i], _UDOD, function(){this.cb(U.PL._ev[i]);}); } }
        },
        load: function (URL) { //播放音乐
            URL = URL || this.cf.urls[this.cf.l]; if (this.vi) { this.vi.url = URL; } else { this.create(URL); }
        },
        play: function (UTF) { //播放还是停止
            this.vi[UTF ? "play" : "pause"]();
        },
        sound: function () { //声音变化

        },
        lpb: function () { //修改播放的位置

        },
        muted: function () { //静音设置

        },
        isPlay: function (UTF, UDOD) { //判断是否允许播放该格式
            return (UDOD || this.vi).canPlayType(this.type[UTF.toLowerCase()]);
        },
        pb: function () { //进度条变化

        },
        Buffer: function () { //缓冲变化

        }
    }
    _UME.init.prototype = _UME; return _;
}

//#endregion

////----------------------------------------------------------------------------未用函数----------------------------------------------------------------------
//切换效果
U.UF.MR.OptionGroupSelect = function (UDOD) {
    var i, _UIE, _UDPD = U.selectEl(UDOD).Parent(), _UDSD = U.selectEl("span", _UDPD), _UDID = U.selectEl("i", _UDPD)[0], _UE = U.UF.EL.getElementInfo(UDOD);
    for (i = 0; i < _UDSD.length; i++) { U.selectEl(_UDSD[i]).addAttrArray({ "style": _UDSD[i] == UDOD ? ($(_UDPD).addAttrArray({ "selectnum": i }), U.selectEl(_UDID).animate({ "left": i * _UE["BCRW"] + "px" }, 100), { "fontWeight": "bold", "color": "White" }) : { "fontWeight": "normal", "color": "#000"} }); }
}


    /**
    * 事件绑定
    *
    * @param  {object} U.DW.local实例对象
    * @param  {object} U.DW.local实例对象
    */
    //    set: function (UDE, USE) { //设置值
    //        if (this.UJE) {
    //            var i, _UME = this.UJE;
    //            (USE != null) && (i = UDE, UDE = {}, UDE[i] = USE);
    //            for (i in UDE) {
    //                (UDE.hasOwnProperty(i)) && (this.UTF ? _UME.setItem(i, UDE[i]) : (_UME.setAttribute(i, UDE[i]), _UME.save("us")));
    //            }
    //        }
    //        return this;
    //    },


    
//动画效果函数
Math.tween = {
    Linear: function (t, b, c, d) { return c * t / d + b; },
    Quad: {
        easeIn: function (t, b, c, d) {
            return c * (t /= d) * t + b;
        },
        easeOut: function (t, b, c, d) {
            return -c * (t /= d) * (t - 2) + b;
        },
        easeInOut: function (t, b, c, d) {
            if ((t /= d / 2) < 1) return c / 2 * t * t + b;
            return -c / 2 * ((--t) * (t - 2) - 1) + b;
        }
    },
    Cubic: {
        easeIn: function (t, b, c, d) {
            return c * (t /= d) * t * t + b;
        },
        easeOut: function (t, b, c, d) {
            return c * ((t = t / d - 1) * t * t + 1) + b;
        },
        easeInOut: function (t, b, c, d) {
            if ((t /= d / 2) < 1) return c / 2 * t * t * t + b;
            return c / 2 * ((t -= 2) * t * t + 2) + b;
        }
    },
    Quart: {
        easeIn: function (t, b, c, d) {
            return c * (t /= d) * t * t * t + b;
        },
        easeOut: function (t, b, c, d) {
            return -c * ((t = t / d - 1) * t * t * t - 1) + b;
        },
        easeInOut: function (t, b, c, d) {
            if ((t /= d / 2) < 1) return c / 2 * t * t * t * t + b;
            return -c / 2 * ((t -= 2) * t * t * t - 2) + b;
        }
    },
    Quint: {
        easeIn: function (t, b, c, d) {
            return c * (t /= d) * t * t * t * t + b;
        },
        easeOut: function (t, b, c, d) {
            return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
        },
        easeInOut: function (t, b, c, d) {
            if ((t /= d / 2) < 1) return c / 2 * t * t * t * t * t + b;
            return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
        }
    },
    Sine: {
        easeIn: function (t, b, c, d) {
            return -c * Math.cos(t / d * (Math.PI / 2)) + c + b;
        },
        easeOut: function (t, b, c, d) {
            return c * Math.sin(t / d * (Math.PI / 2)) + b;
        },
        easeInOut: function (t, b, c, d) {
            return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;
        }
    },
    Expo: {
        easeIn: function (t, b, c, d) {
            return (t == 0) ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
        },
        easeOut: function (t, b, c, d) {
            return (t == d) ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;
        },
        easeInOut: function (t, b, c, d) {
            if (t == 0) return b;
            if (t == d) return b + c;
            if ((t /= d / 2) < 1) return c / 2 * Math.pow(2, 10 * (t - 1)) + b;
            return c / 2 * (-Math.pow(2, -10 * --t) + 2) + b;
        }
    },
    Circ: {
        easeIn: function (t, b, c, d) {
            return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
        },
        easeOut: function (t, b, c, d) {
            return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
        },
        easeInOut: function (t, b, c, d) {
            if ((t /= d / 2) < 1) return -c / 2 * (Math.sqrt(1 - t * t) - 1) + b;
            return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
        }
    },
    Elastic: {
        easeIn: function (t, b, c, d, a, p) {
            var s;
            if (t == 0) return b;
            if ((t /= d) == 1) return b + c;
            if (typeof p == "undefined") p = d * .3;
            if (!a || a < Math.abs(c)) {
                s = p / 4;
                a = c;
            } else {
                s = p / (2 * Math.PI) * Math.asin(c / a);
            }
            return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
        },
        easeOut: function (t, b, c, d, a, p) {
            var s;
            if (t == 0) return b;
            if ((t /= d) == 1) return b + c;
            if (typeof p == "undefined") p = d * .3;
            if (!a || a < Math.abs(c)) {
                a = c;
                s = p / 4;
            } else {
                s = p / (2 * Math.PI) * Math.asin(c / a);
            }
            return (a * Math.pow(2, -10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b);
        },
        easeInOut: function (t, b, c, d, a, p) {
            var s;
            if (t == 0) return b;
            if ((t /= d / 2) == 2) return b + c;
            if (typeof p == "undefined") p = d * (.3 * 1.5);
            if (!a || a < Math.abs(c)) {
                a = c;
                s = p / 4;
            } else {
                s = p / (2 * Math.PI) * Math.asin(c / a);
            }
            if (t < 1) return -.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
            return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p) * .5 + c + b;
        }
    },
    Back: {
        easeIn: function (t, b, c, d, s) {
            if (typeof s == "undefined") s = 1.70158;
            return c * (t /= d) * t * ((s + 1) * t - s) + b;
        },
        easeOut: function (t, b, c, d, s) {
            if (typeof s == "undefined") s = 1.70158;
            return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
        },
        easeInOut: function (t, b, c, d, s) {
            if (typeof s == "undefined") s = 1.70158;
            if ((t /= d / 2) < 1) return c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b;
            return c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
        }
    },
    Bounce: {
        easeIn: function (t, b, c, d) {
            return c - Tween.Bounce.easeOut(d - t, 0, c, d) + b;
        },
        easeOut: function (t, b, c, d) {
            if ((t /= d) < (1 / 2.75)) {
                return c * (7.5625 * t * t) + b;
            } else if (t < (2 / 2.75)) {
                return c * (7.5625 * (t -= (1.5 / 2.75)) * t + .75) + b;
            } else if (t < (2.5 / 2.75)) {
                return c * (7.5625 * (t -= (2.25 / 2.75)) * t + .9375) + b;
            } else {
                return c * (7.5625 * (t -= (2.625 / 2.75)) * t + .984375) + b;
            }
        },
        easeInOut: function (t, b, c, d) {
            if (t < d / 2) {
                return Tween.Bounce.easeIn(t * 2, 0, c, d) * .5 + b;
            } else {
                return Tween.Bounce.easeOut(t * 2 - d, 0, c, d) * .5 + c * .5 + b;
            }
        }
    }
};

U.UF.C.AddObj(U.P, Math.tween);

//#region 画图函数


U.UF.Math.RandomXY = function () {
}

//判断鼠标是否在div上
U.UF.Math.MouseInRect = function (UDOD) {
    var _UE = U.UF.EL.getMousePosition(), _UWH = U.UF.EL.getElementInfo(UDOD);
    return _UE.X > _UWH.BCRL && _UE.X < _UWH.BCRR && _UE.Y > _UWH.BCRT && _UE.Y < _UWH.BCRB;
}

//画点 位置和大小
U.UF.Math.DrawPoint = function (x, y, c, s, con) {
    $$("div", { "style": { "position": "absolute", "left": x + "px", "top": y + "px", "backgroundColor": c || "#000", "width": (s || 1) + "px", "height": (s || 1) + "px"} }, con || document.body);
}

//画线
U.UF.Math.DrawLine = function (x, y, ex, ey, s, c, con) { 
    var i, j, _UL, _USE, _UJE, _UKE, _UX = ex - x, _UY = ey - y, _UDFD = $$("frag"); s = s || 1;
    if (!_UX) { i = Math.min(y, ey); _UL = Math.max(y, ey); for (; i < _UL; i++) { U.UF.Math.DrawPoint(x, i, c, s, _UDFD); } } //画竖线
    else if (!_UY) { i = Math.min(x, ex); _UL = Math.max(x, ex); for (; i < _UL; i++) { U.UF.Math.DrawPoint(x, i, c, s, _UDFD); } } //画横线
    else { //画斜线
        j = i = Math.min(x, ex); _UL = Math.max(x, ex); _UJE = (ey - y) / (ex - x); _USE = Math[_UJE > 0 ? "min" : "max"](y, ey); //sin(a) 斜率以横最为增长值
        for (i; i <= _UL; i++) { U.UF.Math.DrawPoint(i, (i - j) * _UJE + _USE, c, s, _UDFD); } //变化递增
    }
    (con || document.body).appendChild(_UDFD);
}

//画矩形
U.UF.Math.DrawRect = function (x, y, w, h, c, con) { 
    var i, _UTY = y + h, _UDFD = $$("frag");
    for (i = 0; i < w; i++) { U.UF.Math.DrawLine(x + i, y, x + i, _UTY, 1, c, _UDFD); }
    (con || document.body).appendChild(_UDFD);
}

//移除元素
U.UF.Math.Clean = function () {

}

//sin曲线
U.UF.Math.Sin = function (x, y, r, c, w) {
    for (var i = 0; i < r; i++) U.UF.Math.DrawPoint(x + i, y + Math.sin(i / 180 * Math.PI) * 100, c, w);
}

//cos曲线
U.UF.Math.Cos = function (x, y, r, c, w) {
    for (var i = 0; i < r; i++) U.UF.Math.DrawPoint(x + i, y + Math.cos(i / 180 * Math.PI) * 100, c, w);
}

//画圆边框
U.UF.Math.Circle = function (x, y, r, c, w) { 
    var j, i = 0, _s, _UX, _UY; w = w || 1;
    while (i < 360) {
        _UX = Math.sin(Math.PI / 180 * i) * r; _UY = Math.cos(Math.PI / 180 * i) * r; _s = w / 100;
        _s = _s < 0.2 ? 0.2 : (_s > 1 ? 1 : _s); U.UF.Math.DrawPoint(_UX + x, _UY + y, c, w); i += _s;
    }
}

//多边形
U.UF.Math.Polygon = function (xye, c, w) {
    var i, x, y, _UL = xye.length;
    for (i = 0; i < _UL; i++) { U.UF.Math.DrawLine(xye[i].x, xye[i].y, xye[i == _UL - 1 ? 0 : i + 1].x, xye[i == _UL - 1 ? 0 : i + 1].y, w, c); }
}
//#endregion


/*--------------------------------------------------------------未使用到的函数-------------------------------------------------------*/
//判断两个数组大小
U.UF.C.ciArray = function (UOE, UTE) {
    return UOE.length > UTE.length;
}


//类型判断使用，统一执行调用函数
U.UF.C.exe = function () { }

//类型判断,此函数被U.UF.C.getType函数取代，暂没使用
//U.UF.C.getType = function (UAE) {
//    var i, _UDE = ["Array", "Object", "Boolean", "Number", "String", "Function", "RegExp", "Date", "Error", "NaN", "Null", "Undefined"];
//    for (i = 0; i < _UDE.length; i++) { if (U.UF.M["is" + _UDE[i]](UAE)) { return _UDE[i]; } }//判断该UAE是什么类型
//}
//-------------------------------------------------------------------------------------------

/**
* 类型判断
* @param  {object} 需要判断参数类型.
*/
U.UF.C.getType =function (obj){
 return Object.prototype.toString.call(obj)//判断该传入的参数是什么类型
 }

//判断对象
U.UF.Ut.compareObject = function (UOE, UTE) {
    var i, j, _USE = [0, 0], _UDE = arguments;
    if (_UDE.length) {
        for (i = 0; i < _UDE.length; i++) {
            for (j in _UDE[i]) { (_UDE[i].hasOwnProperty(j)) && (_USE[i]++); }
        }
        return _USE[0] > _USE[1];
    }
}


//判断字符串
U.UF.Ut.compareString = function (UOE, UTE) {
    return UOE.localeCompare(UTE) == 1;
}

//判断数字
U.UF.Ut.compareNumber = function (UOE, UTE) {
    return UOE > UTE;
}

//判断时间
U.UF.Ut.compareDate = function (UOE, UTE) {
    return U.UF.D.sizeComparison(UOE, UTE);
}


//判断是否为 Symbol
U.UF.C.isSymbol = function (UDE) {
    if (UDE) { return (typeof UDE == "symbol" || U.UF.C.getType(UDE) == "Symbol"); }

}

//转化成数字

/**
* 判断是否为元素
*
* @param  {string} 元素
* @return  {boolean} 返回是否为元素 同时不为文本元素
*/
U.UF.C.toInteger = function (UDE) {
    var _URE = 0; UDE = Number(UDE); 
    if (!isNaN(UDE) && isFinite(UDE)) {
        _URE = UDE;
    }
    else {
        UDE = UDE || 0; UDE = (UDE > 0 ? 1 : -1) * Math.floor(Math.abs(UDE));
    }
    return Math.max(Math.min(_URE, Number.MAX_SAFE_INTEGER), 0);
}



//监视
U.UF.C.observe = function () {
    U.UF.EV.boundProperties();
}

//取消监视
U.UF.C.unobserve = function () {
    U.UF.EV.boundProperties();
}


//#region jsonp跨域获取数据,1473的项目跨域到百度，只能通过js方式进行跨域。js引用百度的一个js，百度返回一个值。就可以跨域了。

/**
* jsonp跨域获取数据初始化
*
* @param  {object} jsonp参数
----------[call] 回调函数
----------[parameter] 回调参数
* @return  {string} jsonp类对象
*/
U.A.Jsonp = $.Jsonp = function (UDE) {
    var _UTE = new U.A.Jsonp.init(UDE); //初始化jsonp类
    _UTE.send(); //发送请求
    return _UTE;
}

/**
* jsonp初始化对象
*
* @param  {object} jsonp参数
----------[call] 回调函数
----------[parameter] 回调参数
*/
U.A.Jsonp.init = function (UDE) { //初始化Jsonp对象
    U.UF.C.AddObj(this, UDE);
}

U.A.Jsonp.init.prototype = {
    /**
    * jsonp发送请求数据
    *
    */
    send: function () {
        var _URL = this.url, //发送的地址
            _UCE = this.call, //发送的回调函数
            _UPE = this.parameter, //发送的参数
            UDID = U.UF.EV.eventDelegation(function(){this.success();}).id; //设置委托状态 等待回调
        this.UFE = U.UF.DL.asynLoadJs(_URL + (_UCE ? "?callback=" + _UDID + "&" : "") + (_UPE ? "parameter=" + U.UF.C.urlEncode(_UPE) : ""), "js", function(){this.Asyn();}, null, true); //请求数据等待回调
    },

    //异步加载成功
    Asyn: function () { },

    /**
    * jsonp异步回调
    *
    */
    success: function (r) {
        (this.call) && (this.call(r)); //执行回调函数
        U.selectEl(this.UFE).remove(); //删除遗留的jsonp数据文件
    }
}


//#endregion



U.UF.S.browsers = {
    msie: /msie ([\d.]+)|(trident)\/([\d.]+)/, //ie正则
    firefox: /firefox\/([\d.]+)/, //firfox正则
    chrome: /chrome\/([\d.]+)/, //chrome正则
    opera: /opera.([\d.]+)/, //opera正则
    safari: /version\/([\w.]+).*(safari)/ //safari正则
};



/**
例：/disk?id=1235;  拆分为host:www.1473.cn  search:id=123
* 获取url 
*
* @param  {string} url值
* @return  {object} 返回url对象
----------[host] 返回域的地址
----------[search] 返回search
*/
U.UF.C.splitUrl = function (url) {
    //UURL url
    var _UDAD = $$("a", { "href": url }); //新建a标签
    return { "host": _UDAD.href.replace(_UDAD.search, ""), "search": _UDAD.search };
}


    //http://static.zhihu.com/static/js/v2/ui/editor_plugin_code.js

    /*
    var _ = this.getStateTuple(), state = _.state, range = _.range, code = _.code
    if (state !== Plugin.State.EDITABLE) return

    var text, textType = 'text/plain'
    var clipboard = e.getBrowserEvent().clipboardData
    if (clipboard) { // w3c(webkit,opera...)
    if (clipboard.types && goog.array.contains(clipboard.types, textType)) {
    e.preventDefault()
    text = clipboard.getData(textType)
    this.replaceText(range, text)
    }
    } else if (window.clipboardData) { // IE
    text = window.clipboardData.getData('Text')
    if (text) {
    e.preventDefault()
    this.replaceTextIE(range, text)
    }
    } else { // FF
    // TODO：rewrite
    var offset = range.getStartOffset()
    var selectedLength = range.getText().length
    var codeLength = function () {
    return code.firstChild ? goog.editor.node.getLength(code.firstChild) : 0
    }
    var endLength = codeLength() - offset - selectedLength
    setTimeout(function () {
    Plugin.cleanup(code)
    var caretOffset = codeLength() - endLength
    if (code.firstChild) {
    goog.dom.Range.createCaret(code.firstChild, Math.max(offset, caretOffset)).select()
    }
    })
    }

    */




/**
* 右键菜单定位
*
* @param  {string} 需要定位的右键菜单
*/
/*U.UF.C.rightClickMenuLocation = function (UDOD) {
//UDOD 需要定位的元素
var _UDPD = U.UF.EL.offsetParent(UDOD), //获取元素offsetParent
_UEV = U.UF.C.GetMousep(_UDPD), //当前鼠标位置
_UW = [UDOD.offsetWidth, _UDPD.offsetWidth], //记录UUOD的offsetWidth属性
_UH = [UDOD.offsetHeight, _UDPD.offsetHeight]; //记录UUOD的offsetHeight属性
_UEV["X"] = ((_UW[0] + _UEV["X"]) > _UW[1]) ? _UEV["X"] - _UW[0] : _UEV["X"]; //设置top最大范围
_UEV["Y"] = ((_UH[0] + _UEV["Y"]) > _UH[1]) ? _UEV["Y"] - _UH[0] : _UEV["Y"]; //设置left最大范围
$(UDOD).addAttrArray({ "style": { "cssText": "top:" + _UEV["Y"] + "px;left:" + _UEV["X"] + "px"} }); //右键菜单的位置
}*/

/**
* 获取元素的定位位置
*
* @param  {element} 元素
* @return  {array} 返回元素的位置 
----------[0] 元素的top
----------[1] 元素的left
*/
/*U.UF.M.pageXY = function (UDOD) {
var _UTP,
_UDE = [0, 0]; //需要返回的元素的位置
while (UDOD) {
_UTP = U.UF.EL.getStyle(UDOD, "position"); //元素的position
if (_UTP != "static") {
_UDE[0] += UDOD.offsetTop; //元素的上距
_UDE[1] += UDOD.offsetLeft; //元素的左距
}
UDOD = UDOD.offsetParent;
}
return _UDE; //返回
}*/



/**
* 判断元素的属性是自定义属性还是系统属性  true自定义 false固有
*
* @param  {element} 当前元素
* @param  {string} 为元素的各属性
* @return  {number} 位置 
*/
/*U.UF.EL.isCustomAttributes = function (UDOD, UTP) {
UDOD = UDOD || $$("div");
var _UAE = UDOD.attributes; //_UAE 为UDOD的属性集合
if (_UAE) {
if (_UAE[UTP]) { //IE6-7判断是否是自定义属性
return _UAE[UTP].expando == true;
}
else { //是否为自定义属性
return UDOD.getAttribute(UTP) !== null || UDOD[UTP] === void 0;
}
}
}*/

/**
* 判断元素的位于第几个
*
* @param  {element} 当前元素
* @return  {number} 位置 
*/
/*U.UF.EL.indexOfParent = function (UDOD) {
var _UDAD = U.selectEl($(UDOD).Parent()).Child();
return _UDAD.indexOf(UDOD); //判断元素在指定的位置第几个
}*/




//1、[{parentid:1, username:"a"},{parentid:1,username:"b"},{parentid:2,username:"c"}]  = [{parentid:1, username:"a"},{parentid:1,username:"b"}]

////数组、obj({parentid:1,username:"a"}); 10
//U.Json.select = function (UCE, UKE, UT, USE, UDE) {//条件获取
//    var i, _UTF; USE = USE || []; UDE = arguments.length > 4 ? UDE : this.Value;
//    if (Array.isArray(UDE)) { for (i = 0; i < UDE.length; i++) { if (USE.length == UT) { break; } this.select(UCE, UKE, UT, USE, UDE[i]); } }
//    else {//对象添加处理
//        if (this.ifExists(UCE, UDE)) { USE.push(UDE); } //确定本身是否为目标
//        if (UKE === true) { for (i in UDE) { if (USE.length == UT) { break; }; if (U.UF.C.getType(UDE[i]) == "object") { U.Json(UDE[i], this).select(UCE, UKE, UT, USE); } } } //全盘搜索
//        else if (UKE) { if (USE.length != UT && UDE[UKE]) { U.Json(UDE[UKE], this).select(UCE, UKE, UT, USE); }; } //条件搜索
//    }
//    return USE;
//}


//1、[{parentid:1, username:"a"},{parentid:1,username:"b"},{parentid:2,username:"c"}]  = [{parentid:1, username:"a"},{parentid:1,username:"b"}]

//数组、obj({parentid:1,username:"a"});
//U.Json.ifExists = function (UCE, UDE) { //判断数据是否符合条件
//    var i, _UTF;
//    UDE = UDE || this.Value;
//    //判断条件是否就是指定判断的元素，如果是直接返回true，
//    if (UDE === UCE) {
//        return true;
//    }

//    //循环条件，当条件中所有的条件都满足的时候，为true；否则为false
//    for (i in UCE) {
//        if (UCE.hasOwnProperty(i)) {
//            if (UDE[i] === UCE[i]) {
//                _UTF = true;
//            }
//            else {
//                _UTF = false;
//                break;
//            }
//        }
//    }
//    return _UTF;
//}



////初始化json操作区域
////
//U.Json = function () {
//    var _um = U.UF.M; //引用
//    //初始化方法,类似Java中的构造函数，自动执行
//    var _UME, _UFE = function (UDE, UPE) {
//        //new的方式进入
//        if (this.init == _UME.init) {
//            this.init(UDE, UPE);
//        }
//        //直接以函数的方式进入
//        else {
//            return new _UME.init(UDE, UPE);
//        }
//    },
//    cb = function (UTP) { //通过类型获取回调函数形式
//        return function (UDE) {
//            if (UTP == null) {
//                return UDE;
//            } //直接返回使用
//            else if (U.UF.C.isFunction(UTP)) {
//                return UTP.apply(null, arguments);
//            } //函数使用
//            else if (U.UF.C.isObject(UTP)) {
//                return _UME.ifExists(UTP, UDE);
//            } //判断对象的使用
//            return UDE[UTP];  //字符串或者数字
//        }
//    },
//    //
//    maxAndmin = function (UDE, UCE, UII, UTP) {//最大最小统一使用区域
//        if (UDE) {
//            var _USE = -Infinity,
//             _UNE = -Infinity,
//              _UCB = cb(UCE);
//            UDE.forEach(function (UVE, UI) {
//                var _UKE = _UCB.call(UII, UVE, UI, UDE),
//                _UTF = (UTP == "max" && _UKE > _UNE) || (UTP == "min" && _UKE < _UNE);
//                if (_UTF || (_USE === _UNE && _UNE === -Infinity)) {
//                    _UNE = _UKE;
//                    _USE = UVE;
//                } //设置值
//            });
//            return _USE;
//        }
//        else {
//            throw new Error("数组异常");
//        }
//    };




//    //使用方法集
//    _UFE.prototype = _UME = {
//        init: function (UDE, UPE) { //初始化对象
//            this.Value = UDE;
//            this.Parent = UPE || window;
//        },
//        Clone: function (UDE) { //克隆对象 深克隆
//            var i, _UCE; UDE = UDE || this.Value;
//            if (U.UF.C.isObject(UDE)) {
//                _UCE = new UDE.constructor(); //通过源生成对象
//                if (Array.isArray(_UCE)) {
//                    for (i = 0; i < UDE.length; i++) {
//                        _UCE.push(arguments.callee(UDE[i]));
//                    }
//                } //数组处理
//                else {
//                    for (i in UDE) {
//                        if (UDE.hasOwnProperty(i)) {
//                            _UCE[i] = arguments.callee(UDE[i]);
//                        }
//                    }
//                } //对象处理
//                return _UCE;
//            }
//            return UDE;
//        },
//        Add: function (UCE) { //对象添加值
//            var i;
//            var _UDE = this.Value;
//            //判断是对象或者数组，如为数组，采用集合添加模式
//            if (!Array.isArray(_UDE)) {
//                for (i in UCE) {
//                    if (UCE.hasOwnProperty(i)) {
//                        _UDE[i] = UCE[i];
//                    }
//                }
//            }
//            //集合添加模式,但好像没有进入这一个分支,在上传时进入此分支。
//            else {
//                for (i = 0; i < _UDE.length; i++) {
//                    U.UF.C.AddObj(_UDE[i], UCE); //本身添加，太消耗了
//                }
//            } //数组方式为每一个都添加

//            return this.Value;
//        },

//        selectOne: function (UCE, UKE) {//搜索一个(跨层次)
//            return (this.select(UCE, UKE, 1))[0];
//        },
//        invoke: function (UN, UDE) { //自动调用
//            var _UT = this; (UDE) && (_UT = U.Json(UDE));
//            if (_UT[UN]) { return _UT[UN](); } //直接运行
//        },
//        sort: function (UCE, UVE, UDE) { //排序
//            UDE = UDE || this.Value; var _UKE, _UTF = U.UF.C.getType(UDE); (U.UF.C.isString(UCE)) && (_UKE = {}, _UKE[UCE] = 1, UCE = _UKE);
//            if (_UTF === "array") { //数组排序
//                (UDE.sort(function (UO, UT) {
//                    var i, _UIE, _UTF;
//                    if (U.UF.C.isFunction(_UTF)) { _UTF = UCE(UO, UT); } //函数回调查看
//                    else if (U.UF.C.isObject(UCE)) { //对象处理
//                        for (i in UCE) {
//                            if (UCE.hasOwnProperty(i)) {
//                                _UTF = typeof (UO[i] || UT[i] || "");
//                                _UTF = _um["ci" + _UTF.capitalizeFirstLetter()](UO[i], UT[i]);
//                                _UIE = UCE[i];
//                                break;
//                            }
//                        } //排序
//                    }
//                    else {
//                        _UTF = UO > UT;
//                    } _UIE = _UIE || (UVE == -1 ? -1 : 1);
//                    return _UIE * ((_UTF == 1 || _UTF == true) ? 1 : -1);
//                }));
//                return UDE;
//            }
//            else {
//                throw new Error(UDE + " is not an Array");
//            }
//        },
//        groupBy: function (UCE, UDE) {//分组查询
//            var _USE = {}, _UCB = cb(UCE); UDE = UDE || this.Value;
//            UDE.forEach(function (UVE, UI) {
//                var _UKE = _UCB(UVE);
//                (_USE[_UKE] == null) && (_USE[_UKE] = []);
//                _USE[_UKE].push(UVE);
//            });
//            return _USE;
//        },
//        toKeyArray: function (UCE, UDE) { //获取制定键的值
//            var _USE = []; UDE = UDE || this.Value;
//            if (!UDE.length) {
//                _USE.push(UDE[UCE]);
//            } else {
//                UDE.forEach(function (UVE, UI) {
//                    var _UCB = cb(UCE);
//                    _USE.push(_UCB(UVE, UI, UDE));
//                });
//            }
//            return _USE;
//        },
//        Where: function (UCE, UT, UDE, USE) { //条件选择 $gt(>) $lte(<=) $gt(>) $gte(>=) $ne(!=) $in(=) $nin(!=)
//            UDE = UDE || this.Value;
//            var i, j, k, z, _UGE, _UKE, _UFE, _UTE,
//              _UTF = U.UF.C.getType(UDE);
//            USE = USE || [];
//            if (_UTF === "object") { //普通对象处理
//                _UTF = []; for (i in UCE) {
//                    if (UCE.hasOwnProperty(i)) {
//                        _UGE = UCE;
//                        _UTF = [];
//                        _UTE = false;
//                        switch (i) {
//                            case "$or": _UGE = UCE[i];
//                                _UTE = true;
//                                break;
//                        } //or使用  
//                        _UFE: for (j in _UGE) {
//                            if (_UGE.hasOwnProperty(j)) {
//                                _UKE: for (k in _UGE[j]) {
//                                    if (_UGE[j].hasOwnProperty(k)) {
//                                        switch (j) {
//                                            case "$e": _UTF.push(UDE[k] == _UGE[j][k]); break; //=
//                                            case "$ne": _UTF.push(UDE[k] != _UGE[j][k]); break; //!=
//                                            case "$lt": _UTF.push(UDE[k] < _UGE[j][k]); break; //<
//                                            case "$lte": _UTF.push(UDE[k] <= _UGE[j][k]); ; break; //<=
//                                            case "$gt": _UTF.push(UDE[k] > _UGE[j][k]); break; //>
//                                            case "$gte": _UTF.push(UDE[k] >= _UGE[j][k]); break; //>=
//                                            case "$in": for (z = 0; z < _UGE[j][k].length; z++) {
//                                                    if (_UGE[j][k][z] == UDE[k]) {
//                                                        _UTF.push(true);
//                                                        break;
//                                                    }
//                                                } _UTF = !_UTF;
//                                                break; //in
//                                            case "$nin": for (z = 0; z < _UGE[j][k]; z++) {
//                                                    if (_UGE[j][k][z] == UDE[k]) { continue _UKE; }
//                                                }
//                                                _UTF.push(true);
//                                                break; //not in
//                                            case "$all": for (z = 0; z < _UGE[j][k]; z++) {
//                                                    if (_UGE[j][k][z] != UDE[k]) { continue _UKE; }
//                                                }
//                                                _UTF.push(true);
//                                                break; //匹配所有
//                                            case "$exists": break; //存在文档
//                                            case "$mod": break; //取模函数
//                                            case "$not": break; //不匹配
//                                        }
//                                    }
//                                }
//                            }
//                        }
//                    }
//                    if ((_UTE === true && _UTF.indexOf(true) > -1) || (_UTF.indexOf(false) == -1)) {
//                        USE.push(UDE);
//                    }
//                }
//            }
//            else if (_UTF == "array") { //数组选择 
//                for (i = 0; i < UDE.length; i++) {
//                    if (USE.length == UT) {
//                        break;
//                    }
//                    this.Where(UCE, UT, UDE[i], USE);
//                }
//            }
//            return USE;
//        },
//        select: function (UCE, UKE, UT, USE, UDE) {//条件获取
//            var i, _UTF;
//            USE = USE || [];
//            UDE = arguments.length > 4 ? UDE : this.Value;
//            if (Array.isArray(UDE)) {
//                for (i = 0; i < UDE.length; i++) {
//                    if (USE.length == UT) {
//                        break;
//                    }
//                    this.select(UCE, UKE, UT, USE, UDE[i]);
//                }
//            }
//            else {//对象添加处理
//                if (this.ifExists(UCE, UDE)) {
//                    USE.push(UDE);
//                } //确定本身是否为目标
//                if (UKE === true) {
//                    for (i in UDE) {
//                        if (USE.length == UT) {
//                            break;
//                        };
//                        if (U.UF.C.getType(UDE[i]) == "object") {
//                            U.Json(UDE[i], this).select(UCE, UKE, UT, USE);
//                        }
//                    }
//                } //全盘搜索
//                else if (UKE) {
//                    if (USE.length != UT && UDE[UKE]) {
//                        U.Json(UDE[UKE], this).select(UCE, UKE, UT, USE);
//                    };
//                } //条件搜索
//            }
//            return USE;
//        },
//        Change: function (UCE, UDE) {//修改值
//            var i, _UDE = arguments.length > 1 ? UDE : this.Value, _UTF = U.UF.C.getType(_UDE);
//            if (_UTF == "object") {
//                for (i in UCE) {
//                    if (UCE.hasOwnProperty(i)) {
//                        _UDE[i] = UCE[i];
//                    }
//                }
//            } //对象修改形式
//            else if (_UTF == "array") {
//                for (i = 0; i < _UDE.length; i++) {
//                    this.Change(UCE, _UDE[i]);
//                }
//            } //数组修改方式   U.Json(_UDE[i], this).Change(UCE); 
//            return _UDE;
//        },
//        //obj 是一个object，是待删除的元素的关键字，在数组中删除含有该object的元素,digui是bool型
//        //UKE 是  1、bool类型。如果为true，表示全递归查找数据,默认为false，不递归查找
//        //        2、或者str   例如：{"directory":"C盘","children":[{"directory":"windows","children":[]},{"directory":"programfiles","children":[]}]} 中的"children"，根据此key去递归向下查找数据。找到数据后，匹配第一个参数，进行删除。
//        //        3、是递归参数，外部不调用。                    
//        del: function (obj, key, data) { //删除 允许递归


//            var i, _deldata;
//            data = data || this.Value; //传递进来的json数据

//            var _type = U.UF.C.getType(data); //获取元素类型
//            var _delarray = []; //返回的删除数据。


//            if (_type == "object") { //对象删除
//                if (this.ifExists(obj, data)) {
//                    delete data;
//                    _delarray.push(data);
//                }
//                else if (key === true) { //递归删除
//                    for (i in data) {
//                        _deldata = this.del(obj, key, data[i]); //递归删除该数据
//                        _delarray = _delarray.concat(_deldata); //把删除的数据追加到变量中
//                    }
//                }
//                else if (key && data[key]) { //根据指定的key进行递归删除
//                    _deldata = this.del(obj, key, data[key]); //根据指定的key递归删除该数据
//                    _delarray = data.concat(_deldata);
//                }
//            }
//            //数组删除指定obj条件的元素
//            else if (_type === "array") {
//                for (i = 0; i < data.length; i++) {
//                    //循环删除 获取移除的元素
//                    _deldata = this.del(obj, key, data[i]);
//                    if (_deldata.length) { //判断是否移除了元素，length大于0相当于移除超过一个元素。
//                        data.splice(i, 1); //数组的系统移除方法
//                        _delarray = _delarray.concat(_deldata); //把移除的元素添加到变量中
//                        i--; //由于上面用了循环i++ 移除元素后 数组的下标减一了，所以这里用i--让i回到前面一个循环，这样即使数组删除了一个元素也不会直接跳过下一个元素的循环
//                    }
//                }
//            } //数组使用
//            return _delarray;
//        },

//        RecurD: function (UCE, UKE, UTP) { //数据递归
//            var _UAE, _UGE, i = UCE ? (_UGE = [UCE], 0) : (_UGE = [], -1), _UDE = this.Value;
//            if (Array.isArray(_UDE)) {
//                for (; i < _UGE.length; i++) {
//                    if (i > -1) { for (j in UKE) { UKE[j] = _UGE[i][UTP]; } }
//                    _UAE = U.Json.select(_UDE,UKE)[0]; (_UAE) && (_UGE.push(_UAE));
//                }
//            }
//            else {
//                while (_UGE[4][UKE]) {
//                    _UDE.push(_UGE[4][_UPID]);
//                    _UPID = _UGE[4][i]["UserDirectoryParentID"]
//                }
//            }
//            return _UGE;
//        },
//        NL: function (UCE, USE) { //通过数组生成集合
//            var i, _UDE = this.Value;
//            for (i = 0; i < UCE.length; i++) {
//                _UDE[UCE[i]] = USE[i];
//            }
//            return _UDE;
//        },
//        Reset: function (UCE) { //数组排序
//            var i, _UDE = this.Value;
//            for (i = 0; i < _UDE.length; i++) {
//                if (this.ifExists(UCE, _UDE[i])) {
//                    _UDE.unshift(_UDE.splice(i, 1)[0]);
//                }
//            }
//            return _UDE;
//        },
//        Like: function (UCE, UT, UKE, USE) { //like使用
//            var i, _US, _UE,
//             _UDE = this.Value,
//             _UTF = U.UF.C.getType(_UDE);
//            USE = USE || [];
//            if (_UTF == "object") {
//                for (i in UCE) {
//                    if (UCE.hasOwnProperty(i)) {
//                        if (_UDE[i] != UCE[i]) {
//                            if (typeof _UDE[i] == "object" || typeof _UDE[i] == "object") {
//                                return;
//                            }
//                            _US = (_UDE[i] + "").toLocaleLowerCase(); _UE = (UCE[i] + "").toLocaleLowerCase();
//                            if (!(_US.indexOf(_UE) > -1 || _UE.indexOf(_US) > -1)) {
//                                return;
//                            }
//                        }
//                    }
//                }
//                USE.push(_UDE);
//            }
//            else if (_UTF === "array") {
//                for (i = 0; i < _UDE.length; i++) {
//                    U.Json(_UDE[i], this).Like(UCE, UT - USE.length, UKE, USE);
//                    if (USE.length >= UT) {
//                        USE.splice(UT, USE.length);
//                        break;
//                    }
//                }
//            }
//            return USE;
//        },
//        GZDL: function (UCE, UDE) {//选择指定字段的值
//            var i, _UKE = {}, _UDE = this.Value;
//            (U.UF.C.isString(UCE)) && (UCE = [UCE]);
//            for (i = 0; i < UCE.length; i++) { _UKE[UCE[i]] = _UDE[UCE[i]]; }
//            return _UKE;
//        },
//        //UCE是一个object，UDE是json。判断json中的数据是否包含该object。
//        //例：{name:张三,身高:1.8,体重:150}  查找{name:张三,身高:1.8},则符合条件,返回true，查找{name:张三,身高:1.5}，则不符合条件，返回false.
//        ifExists: function (UCE, UDE) { //判断数据是否符合条件
//            var i, _UTF;
//            UDE = UDE || this.Value;
//            //判断条件是否就是指定判断的元素，如果是直接返回true，
//            if (UDE === UCE) {
//                return true;
//            }

//            //循环条件，当条件中所有的条件都满足的时候，为true；否则为false
//            for (i in UCE) {
//                if (UCE.hasOwnProperty(i)) {
//                    if (UDE[i] === UCE[i]) {
//                        _UTF = true;
//                    }
//                    else {
//                        _UTF = false;
//                        break;
//                    }
//                }
//            }
//            return _UTF;
//        },
//        //#error
//        Merger: function (UDE) {//合并成数组分组
//            UDE = UDE || this.Value;
//            var i,
//            _USE = [],
//             _UTP = U.UF.C.getType(this.Value);
//            if (_UTP == "object") {
//                for (i in UDE) {
//                    if (UDE.hasOwnProperty(i)) {
//                        _USE = _USE.concat(UDE[i]);
//                    }
//                }
//            }
//            else if (_UTP == "array") {
//                for (i = 0; i < UDE.length; i++) {
//                    _USE = _USE.concat(UDE[i]);
//                }
//            }
//            return _USE;
//        },
//        ToString: function () { return U.UF.C.jsonToStr(this.Value); }, //把json 数组变成string
//        Each: function (cb, UDE) { //数据遍历
//            if (U.UF.C.isFunction(cb)) {
//                UDE = UDE || this.Value;
//                var i,
//                 _UTF = U.UF.C.getType(UDE);
//                if (_UTF == "object") {
//                    for (i in UDE) {
//                        if (UDE.hasOwnProperty(i)) { cb(UDE[i], i, UDE) };
//                    }
//                }
//                else if (_UTF === "array") {
//                    Array.forEach(function () {
//                        cb.apply(UDE, arguments);
//                    });
//                }
//            }
//            return this;
//        },
//        //未使用   
//        max: function (UCE, UTI, UDE) {//获取最大
//            maxAndmin(UDE || this.Value, UCE, UTI, "max");
//        },
//        min: function () {//获取最小
//            maxAndmin(UDE || this.Value, UCE, UTI, "min");
//        },
//        object: function (UCE, UDE) {//把数组转化成object
//            var i, _USE = {}; UDE = UDE || this.Value;
//            for (i = 0; i < UCE.length; i++) {
//                return _USE[UCE[i]] = UDE[i];
//            }
//            return _USE;
//        },
//        countBy: function (UFE, UDE) { //统计使用
//            UDE = UDE || this.Value;
//            var i, _UTF,
//             _USE = {},
//              _UTP = U.UF.C.getType(UDE);
//            if (_UTP == "array") {
//                for (i = 0; i < UDE.length; i++) {
//                    _USE[UFE(UDE[i])] = (_USE[UFE(UDE[i])] || 0) + 1;
//                }
//            }
//            else {
//                throw new Error(UDE + " is not an Array");
//            }
//        },
//        where: function (UCE, UDE) { //获取制定的值
//            var i = 0, _USE = []; UDE = UDE || this.Value;
//            while (i++ < _UDE.length) {
//                (this.ifExists(UCE, UDE)) && (_USE.push(UDE[i]));
//            }
//            return _USE;
//        },
//        count: function () {//统计返回的数
//            return this.Value.length;
//        },
//        distinct: function () {//去除重复的数据

//        },
//        find: function () { //模拟数据库查询

//        },
//        each: function () { },
//        has: function (UCE, UDE) {
//            UDE = UDE || this.Value; var i;
//            if (typeof UCE == "string") {
//                if (UCE in UDE && UDE.hasOwnProperty(UCE)) {
//                    return true;
//                }
//            }
//            else {
//                for (i in UCE) {
//                    if (!(i in UDE && UDE.hasOwnProperty(i))) {
//                        return false;
//                    }
//                } return true;
//            } return false;
//        },
//        range: function (US, UE, UT) { //产生带编号的数组
//            var _UDE = [],
//            i = US || 0,
//             _UL = (UE - US);
//            UT = UT || (UE - US) > 0 ? 1 : -1;
//            if (_UL) {
//                _UL = Math.max(Math.ceil(_UL /= UT), 0);
//                for (i = 0; i < _UL; i++) {
//                    US += UT; _UDE.push(US);
//                }
//            }
//            return _UDE;
//        },
//        isEqual: function (UCE, UDE) { //两个值深度比较
//            UDE = UDE || this.Value;
//            var i,
//            _UTP = U.UF.C.getType(UDE),
//             _UFE = Object.prototype.toString.call;
//            if (_UFE(UDE) === _UFE(UCE)) {
//                if (_UTP == "object") {
//                    return (this.ifExists(UCE, UDE) && this.IsTF(UDE, UCE));
//                } //对象判断
//                else if (_UTP == "array" && UDE.length == UCE.length) {
//                    i = UDE.length;
//                    while (i--) {
//                        if (!this.isEqual(UDE[i], UCE[i])) {
//                            return false;
//                        }
//                    }
//                } //数组判断
//                return true;
//            }
//            return false;
//        },
//        isMatch: function (UCE, UDE) { //判断指定的值是否存在
//            UDE = UDE || this.Value;
//            var i,
//             _UTP = U.UF.C.getType(UDE);
//            if (_UTP == "object") {
//                return this.ifExists(UCE);
//            } //集合使用
//            throw new Error("参数必须为对象");
//        }
//    }
//    _UME.IsTF = _UME.ifExists; //重载
//    _UME.init.prototype = _UME;

//    return _UFE; //返回的初始化方法，所以会自动执行java中的构造函数。

//}


//#ednregion


/** #error
* 当你点击enter键时触发的函数 待删除
*
* @param  {object} resize对象
*/
//U.UF.C.returnkeylogin = function (UEL, fun) {
//    var i; //循环初始化
//    if (event.keyCode == 13 || event.keyCode == 10) {
//        if (fun) {//执行函数
//            U.UF.C.apply(UEL || this, fun)();
//        }
//        else if (UEL) {//元素触发使用
//            for (i = 0; i < UEL.length; i++) {
//                UEL[i]["obj"][UEL[i]["event"]]();
//            }
//        }
//        U.UF.EV.stopDefault(); //阻止浏览器默认事件
//    }
//}



/**
* 判断字符串是否为Guid
*
* @param   {string} 需要判断的字符串
* @return  {boolean} 是否为guid
*/
U.UF.Ut.isGuid = function (UST) {
    return Guid.IsGuid(UST);
}

/**
* 是否参与for in循环的对象
*
* @param   {object} 判断是否允许参加在for循环里
* @return  {boolean} 允许for in
*/
U.UF.Ut.isForObj = function (UDE) {
    var i,
    _ = ["isArray", "isFunction", "isObject"]; //三种可参与for in的
    for (i = 0; i < _.length; i++) {
        if (U.UF.Ut[_[i]](UDE)) {
            return _[i].substr(2);
        }
    }
    return false;
}

/**
* 判断对象是否为hemlcontrol
*
* @param  {element} 元素
* @return  {boolean} 判断是否为正常元素
*/
U.UF.Ut.isHtmlElement = function (el) {
    return el.nodeType != null || el == window || el == document || el.frames != null;
}


/**
* 此函数代替U.Json中的Add方法，以避免调试难调，速度降低的问题。
* @param  {object 、 array} 自定义变量或者Array,Object等系统变量，
* @param  {object} 属性的集合，形如：{ "domain": "1473.cn", "SystemId": 0}
*/
U.UF.Ut.AddProperty = function (UDE, UAE) {
    //判断是集合或者集合数组，分别调用上2个函数。
    Array.isArray(UDE) ? U.UF.Ut.AddArr(UDE, UAE) : U.UF.C.AddObj(UDE, UAE);
}

/**
* 判断值是否等于formdate
*
* @param   {object} 需要判断的FormData
* @return  {boolean} 是否为FormData
*/
U.UF.Ut.isFormData = function (obj) {
    return obj.toString() === "[object FormData]";
}

/**
* 判断是否为基础类型
*
* @param  {object} undefined function string number object
* @return  {boolean} true/false
*/
U.UF.Ut.isPrimitive = function (UDE) {
    var i, _UCE = ["undefined", "function", "string", "number", "object"];
    return _UCE.some(function (UCE, UIE) {
        return (typeof UDE) == UCE;
    });
}

/**
* 判断是否为传参类
*
* @param  {object} 函数值
* @return  {boolean} 返回是否为Arguments对象
*/
U.UF.Ut.isArguments = function (UDE) {
    return (typeof (UDE == "object") && U.Json.has(UDE, "callee"));
}


/**
* 判断object是否是空对象
*
* @param  {object} 对象值
* @return  {boolean} 是否空对象
*/
U.UF.Ut.isEmpty = function (UDE) {
    var i,
    _UTF = true;
    for (i in UDE) {
        if (UDE.hasOwnProperty(i)) { _UTF = false; break; }
    }
    return _UTF;
}
/**
* flash加载成功后给flash设置参数
* @param  {element} flash按钮
* @param  {object} flash按钮大小样式 {width:"", height:""}
* @param  {object} flash按钮回调函数 { error : function(e){ console.log("发生错误了") } }
* @param  {string} flash上传的格式设置默认是 * 所有格式都支持
*
*/
U.UF.UP.flashUploadInit = function (flashbootom, style, callback, uploadtype) {
    //判断flash是否已经加载好可以设置
    if (flashbootom.SetStage) {
        flashbootom.SetStage(style, callback, uploadtype || "*"); //加载插件初始化
        return true;
    }
    return false;
}