CocoRoboDesktop/js/UForm/WindowFunction.js

Namespace.register("U.UF.F");

//#region 窗体放大缩小

//窗体的全局变量
U.UF.F.isTop = false; //置顶的全局判断
U.UF.F.hisTory = true; //判断是否保留最大化之前的窗体宽、高、top、left值

/*
*   遮罩框
*  由于在拖动拉伸等过程中可能会触发到其他iframe，这里就是全局遮罩，让拖动和拉伸的过程中，不回出发到下面的iframe
*/
U.UF.F.maskFrame = function () {
    return $$("div", { "style": { "cssText": "width:100%;height:100%;position:absolute;top:0;left:0;" } }, document.body);
}

/*
** 作用：窗体的最大化和最小化功能
** @param {element} el 整个窗体的元素
*/
U.UF.F.windowZooming = function (el) {
    var _csstext = el.initcsstext, //初始化的csstext
        _ismax = el.ismaximize; //判断窗体是否已经最大化了
    //如果最大化了，那么就把他缩小
    if (_ismax) {
        el.style.cssText = _csstext;
        el.ismaximize = false;
    }
    //最大化处理
    else {
        //判断是否一开始就是最大化
        _ismax = document.body.offsetHeight == el.offsetHeight && document.body.offsetWidth == el.offsetWidth;
        if (_ismax) {
            el.style.cssText += "width:70%;height:90%;";
            U.UF.F.windowTopCenter(el);
        }
        else {
            el.initcsstext = el.style.cssText; //获取原本的csstext值
            el.ismaximize = true;
            //设置窗体最大化
            U.selectEl(el).css({
                "width": "100%",
                "height": "100%",
                "top": "0px",
                "left": "0px"
            });

        }
    }
    //U.MD.F.W.reSize();
}

/*
** 作用：窗体的最小化功能
** @param {element} el 整个窗体的元素
*/
U.UF.F.windowMinimize = function (el) {
    //添加样式，实现动画效果，并且逐渐隐藏整个窗体
    el.style.cssText += "display:none";
    //-ms-transform:scale(0.5);-webkit-transform:translateX(100%); -o-transform:scale(0.5); transform:scale(0.5);
}

/*
** 作用：窗体的关闭功能
** @param {element} el 整个窗体的元素
** @param {string} str 操作指令
*/
U.UF.F.closeWindow = function (el, str) {
    var _el = U.selectEl(el); //获取整个窗体的元素
    if (_el[0].style.display != "none" && str == "remove") {//判断窗体是否被隐藏，并且操作指令为remove
        _el.remove(); //移除整个窗体
        _el = null; //移除整个窗体
    }
    else {
        _el.css("display", "none");
    }
}

/*
** 作用：窗体的居中功能
** @param {element} el 整个窗体的元素
*/
U.UF.F.windowTopCenter = function (el) {
    //异步弹出窗体置顶，因为在我们的窗体点击的时候回切换置顶，但在在里面点击应用的时候，会导致先置顶应用（调用了该函数）.然后又制定点击对应的窗体。
    //setTimeout(function () {
    //获取实际高度或者是当前窗口对于窗口显示区左上角的Y位置或者是整个body的实际高度
    var _scrollTop = document.documentElement.scrollTop || window.pageYOffset || document.body.scrollTop,
        //获取整个页面的宽度
        _iwidth = document.documentElement.clientWidth,
        //获取整个浏览器的宽度
        _iheight = document.documentElement.clientHeight; //_scrollTop * 2
    el.style.display = "block"; //先显示窗体
    _zindex = (US || parent.US).ZINDEX++;
    U.selectEl(el).css({
        "zIndex": _zindex,
        //获取整个窗体的left的值为浏览器窗口文档显示区域的宽度不包括滚动条减去窗体的文档显示区域在除以2再加上实际宽度
        "left": (_iwidth - el.clientWidth) / 2 + "px",
        //获取整个窗体的left的值为浏览器窗口文档显示区域的高度不包括滚动条减去窗体的文档显示区域在除以2再加上实际高度
        "top": (_iheight - el.clientHeight) / 2 + "px"
    });
    //}, 0);
}
/*
** 作用：窗口的置顶功能
** @param {element} el 整个窗体的元素
** @param {string} str 是否为true
1、获取点击元素
2、给点击元素父级元素的z-index+1
*/
U.UF.F.topWindow = function (el) {
    var _zindex,
        _el1 = U.UF.F.getWindow(el), //通过U.UF.F.getWindow()获取需要进行置顶的窗体元素
        _el3; //获取需要置顶元素的父级元素
    if (_el1 && _el1.length || el && el.length) {//判断是否有需要置顶的窗体元素
        for (var i = 0; i < _el1.length; i++) {//循环判断有几个窗体元素
            _el3 = U.selectEl(_el1[i]).Parent();
            //判断 是否有获取需要置顶的窗体元素的父级元素 并且 需要置顶的元素是否符合document.body或者id是否符合"usestudio_server"或者id是否符合"U_MD_Home"三种中的一种，并且是否需要置顶的元素"__top__"不为false，并且操作指令为true或者返回值在字符串中首次出现的位置是否为-1
            if (_el3 && (_el3 == document.body || _el3.id == "usestudio_server") && ($(_el1[i]).attr("__top__") != "false" && _el1[i]["__top__"] != "false")) {
                _zindex = (US || parent.US).ZINDEX++;
                //如果符合全部要求，则给置顶元素添加一个style样式，z-index每一次置顶都在现有的z-index中加1，并且显示出来
                U.selectEl(_el1[i]).addAttrArray({ "style": { "cssText": _el1[i].style.cssText + ";z-index:" + _zindex + ";display:block" } });
            }
        }
    }
}

/*
** 作用:获取顶层窗体的功能
** @param {element} el 整个窗体的元素
*/
U.UF.F.getWindow = function (el) {
    var _arr = [], //先定义一个用于存储需要置顶元素的元素
        _el2 = el, //获取整个窗体的元素
        _el3 = document.body, //获取整个文档的body部分，不包括除body外的一切
        _el4 = U.selectEl("#U_MD_Home")[0] || U.selectEl("#usestudio_server")[0] || _el3; //获取满足三个条件中的一个的元素
    //判断是否有满足三个条件中的一个的元素
    if (_el4) {//如果有,则进行下面的语句
        //循环语句，整个窗体的元素为元素的offsetParent，并且.获取的窗体元素不为整个body的部分，也不是满足获取id为U_MD_Home和id为usestudio_server的元素，并且条件满足的情况下进行循环批判断，直到结果出现
        while ((_el2 = U.UF.EL.offsetParent(_el2, true)) && (_el2 && (_el2 != _el4 && _el2 != _el3))) {//因为这条语句没有循环限定次数，所以适用while循环语句
            if (_el2.style.position != "relative") {
                _arr.push(_el2); //如果条件满足，则向_arr这个存储元素的末尾添加一个窗体元素
            }
            _el2 = _el2.parentNode; //并且把窗体的父节点赋值给新的_el2元素

        }
        return _arr; //最后返回需要置顶的窗体元素的数组
    }
}

/*
**	作用：桌面窗体自动分层次处理,点击窗口自动分层，不会叠加
**	@param {callback} cb 回调函数，调用分层函数
**	@param {boolean} b 操作指令，知否为true或者false
**	@param {element} el 获取窗体元素
*/
U.UF.F.clickTopWindow = function (cb) {
    //设置点击置顶的功能
    U.selectEl(document.body).bind({
        mousedown: function () {
            //判断点击置顶有回调函数则回调
            if (U.UF.C.isFunction(cb)) {
                cb(event.srcElement, true);
            }
            //置顶窗体处理
            top.U.UF.F.topWindow(event.srcElement, true);
        }
    });
}

//#endregion

//#region 拉伸

/*
* 拉伸函数处理
*
* 1 @param obj1 = {object} 需要拉伸的窗体
* 3 @param str ={string}  判断拉伸是哪个方位
实例：U.UF.F.stretching（$(".窗体")[0],拉伸类型）
拉伸类型：
bottom  * 向下
right  * 向右
top   * 向上
left  * 向左
rightBottom  * 右下
rightTop  * 右上
leftTop  * 左上
leftBottom * 左下
*/
U.UF.F.stretching = function (obj1, str) {
    var e = window.event; //获取当前鼠标点击事件
    //target 就是这个对象
    //target = e.srcElement || e.target
    //这个对象的值
    //targetValue = target.value;
    var _disX, _disY, _dragMinWidth = 70, _dragMinHeight = 70;
    //_dragMinWidth _dragMinHeight设置窗口拉伸最小宽度和高度
    // obj2.onmousedown = function (e) { //div的点击执行
    //e = e || event;  //获取当前event的信息赋予e
    e.preventDefault(); //取消event事件的默认动作
    _disX = e.clientX; //当事件被触发时鼠标指针向对于浏览器页面(或客户区)的水平坐标 
    _disY = e.clientY; //当事件被触发时鼠标指针向对于浏览器页面(或客户区)的垂直坐标
    var _iparenttop = obj1.offsetTop; //当前窗口距离可视窗口顶部的距离
    var _iparentleft = obj1.offsetLeft; //当前窗口距离可视窗口左部的距离
    var _iparentwidth = obj1.offsetWidth; //当前窗口的宽度
    var _iparentheight = obj1.offsetHeight; //当前窗口的高度
    if (!$("#U_UF_F_drag_flag")[0]) {
        var _div = $$("div", { "style": { "cssText": "width: 100%;height: 100%;z-index: 99999;position: absolute;top:0;left:0;" }, "id": "U_UF_F_drag_flag" }, document.body);
        //    _top = U.selectEl(U.UF.UI.form.allForm[_drag.id].header).height();
        //   U.selectEl(_div)[0].style.top = _top + "px";
    }
    var _windowfun = {
        "mousemove": function (e) { //拉伸移动执行
            e = e || event; //获取在鼠标移动的时候event的信息
            var _iL = e.clientX - _disX - 3; //返回当事件被触发时鼠标指针向对于浏览器页面(或客户区)的水平坐标-减去-之前窗体距离左边的距离 剩下的就是改变后的宽度
            //_iL 相当于 窗体要移动的距离
            var _iT = e.clientY - _disY; //返回当事件被触发时鼠标指针向对于浏览器页面(或客户区)的垂直坐标-减去-之前窗体距离顶部的距离 剩下的就是改变后的高度
            //_iT 相当于 窗体要移动的高度
            var _maxw = document.documentElement.clientWidth - _iparentleft - 2; //获取窗体向右扩张最大宽度（网页可视宽度减去-当前窗口距离可视窗口左部的距离）剩下最大的宽度
            var _maxh = document.documentElement.clientHeight - _iparenttop - 2; //获取窗体向下扩张最大高度 （网页可视高度减去-当前窗口距离可视窗口顶部的距离）剩下最大的高度
            if (str == "bottom") {
                var _ih = _iT + _iparentheight; //获取拉伸后窗体改变的高度
                if (_ih < _dragMinHeight) { _ih = _dragMinHeight } else if (_ih > _maxh) { _ih = _maxh; };
                //第一先判断改变后的高度有没有低于自己设置的最小高度如果小于就命改变后的高度变成最小高度
                //第二判断改变后的高度有没有大于 之前获取的最大高度  如果大于就命 改变后的高度变成最大高度
                obj1.style.height = _ih + 'px'; //执行

            }
            if (str == "right") {
                var _iw = _iL + _iparentwidth//获取拉伸后窗体改变的宽度  
                if (_iw < _dragMinWidth) {
                    _iw = _dragMinWidth
                } else if (_iw > _maxw) {
                    _iw = _maxw;
                }; //判断改变后的宽度有没有低于自己设置的最小宽度，如果有就变成最小的宽度，
                //第二判断改变后的宽度有没有大于自己设计的最大宽度如果有就命改变后的宽度变成最大的宽度
                obj1.style.width = _iw + 'px'; //执行
            }
            if (str == "top") {
                var _ih = _iparentheight - _iT  //获取拉伸后窗体改变的高度  向下拉就是窗体剩余的高度
                obj1.style.top = _iparenttop + _iT + 'px'; //执行窗体改变后距离可视窗口头部的距离
                if (obj1.style.top < '0') {
                    obj1.style.top = '0px';
                    document.onmousemove = null;
                } //判断刚刚赋予的值有没有小于0 防止窗口拉伸到外面
                if (_ih < _dragMinHeight) {//之前定义了一个属性值高度防止小于窗体高度
                    var _bh = _ih  //赋予值
                    _ih = _dragMinHeight; //赋予值
                    obj1.style.top = (_iparenttop + _iT) - (_dragMinHeight - _bh) + 'px';  //（之前距离头部的距离 + 要添加的y值） - （之前设置的最小高度值 - 获取拉伸后窗体改变的高度）
                }
                obj1.style.height = _ih - '2' + 'px'; //赋予
            }
            if (str == "left") {
                var _iw = _iparentwidth - _iL // 窗体改变前的宽度 减去 窗体拉伸的长度  
                obj1.style.left = _iparentleft + _iL + 'px'; //当前窗口距离可视窗口左部的距离 + 窗体要移动的距离 (通常为负数)
                if (_iw < _dragMinWidth) {//之前定义了一个属性值宽度防止小于窗体宽度
                    var _bl = _iw
                    _iw = _dragMinWidth
                    obj1.style.left = (_siparentleft + _iL) - (_dragMinWidth - _bl) + 'px'; //（之前距离左边的距离 + 要添加的x值） - （之前设置的最小宽度值 - 获取拉伸后窗体改变的宽度）
                }
                obj1.style.width = _iw - '2' + 'px';
            }
            if (str == "rightBottom") {
                var _iw = _iL + _iparentwidth;  //获取拉伸后窗体改变的宽度
                var _ih = _iT + _iparentheight; //获取拉伸后窗体改变的高度
                if (_iw < _dragMinWidth) {//之前定义了一个属性值宽度防止小于窗体宽度
                    _iw = _dragMinWidth  //赋予值
                } else if (_iw > _maxw) {
                    _iw = _maxw;
                }; //防止扩张的时候超出向右扩张最大范围
                obj1.style.width = _iw - '2' + 'px';  //-2 是窗体的div本身的厚度 
                if (_ih < _dragMinHeight) {//之前定义了一个属性值高度防止小于窗体高度
                    _ih = _dragMinHeight;  //赋予值
                } else if (_ih > _maxh) {
                    _ih = _maxh;
                }; //防止扩张的时候超出向下扩张最大高度
                obj1.style.height = _ih + 'px';  //赋予值

            }
            if (str == "rightTop") {
                var _iw = _iL + _iparentwidth;  //获取拉伸后窗体改变的宽度
                var _ih = _iparentheight - _iT; //获取拉伸后窗体改变的高度  
                obj1.style.top = _iparenttop + _iT + 'px';  //当前窗口距离可视窗口顶部的距离 + 改变后的距离
                if (obj1.style.top < '0') { obj1.style.top = '0px'; document.onmousemove = null; } //为了防止拉伸的时候超出边界 
                if (_iw < _dragMinWidth) {//之前定义了一个属性值宽度防止小于窗体宽度
                    _iw = _dragMinWidth  //赋予值
                } else if (_iw > _maxw) { _iw = _maxw; };  //如果改变后的宽度超出最大的宽度则。
                obj1.style.width = _iw + 'px';  //赋予值
                if (_ih < _dragMinHeight) {//之前定义了一个属性值高度防止小于窗体高度
                    var _bh = _ih   //赋予值
                    _ih = _dragMinHeight;  //赋予值
                    obj1.style.top = (_iparenttop + _iT) - (_dragMinHeight - _bh) + 'px';  //（之前距离头部的距离 + 要添加的y值） - （之前设置的最小高度值 - 获取拉伸后窗体改变的高度）
                } else if (_ih > (_iparenttop + _iparentheight)) {
                    _ih = (_iparenttop + _iparentheight)
                }; //如果扩展的高度超过了  （当前窗口距离可视窗口顶部的距离 + 当前窗口的高度）则防止扩张的时候超出范围
                obj1.style.height = _ih - '2' + 'px'; //赋予值

            }
            if (str == "leftTop") {
                var _iw = _iparentwidth - _iL   // 窗体改变前的宽度 减去 窗体拉伸的长度  
                obj1.style.left = _iparentleft + _iL + 'px'; //当前窗口距离可视窗口左部的距离 + 窗体要移动的距离 (通常为负数)
                var _ih = _iparentheight - _iT //获取拉伸后窗体改变的高度  
                obj1.style.top = _iparenttop + _iT + 'px'; //当前窗口距离可视窗口顶部的距离 + 改变后的距离
                if (obj1.style.top < '0') { obj1.style.top = '0px'; document.onmousemove = null; } //为了防止拉伸的时候超出边界 
                if (_iw < _dragMinWidth) {//之前定义了一个属性值宽度防止小于窗体宽度
                    var _bl = _iw;    //赋予值
                    _iw = _dragMinWidth; //赋予值
                    obj1.style.left = (_iparentleft + _iL) - (_dragMinWidth - _bl) + 'px'; //（之前距离左边的距离 + 要添加的x值） - （之前设置的最小宽度值 - 获取拉伸后窗体改变的宽度）
                } else if (_iw > (_iparentleft + _iparentwidth)) {
                    _iw = (_iparentleft + _iparentwidth)
                }; //如果改变后的宽度超过当前窗口距离可视窗口左部的距离 + 窗体改变前的宽度则
                obj1.style.width = _iw - '2' + 'px'; //赋予值
                if (_ih < _dragMinHeight) {//之前定义了一个属性值高度防止小于窗体高度
                    var _bh = _ih; //赋予值
                    _ih = _dragMinHeight; //赋予值
                    obj1.style.top = (_iparenttop + _iT) - (_dragMinHeight - _bh) + 'px'; //（之前距离头部的距离 + 要添加的y值） - （之前设置的最小高度值 - 获取拉伸后窗体改变的高度）
                } else if (_ih > (_iparenttop + _iparentheight)) {
                    _ih = (_iparenttop + _iparentheight)
                }; //如果扩展的高度超过了  （当前窗口距离可视窗口顶部的距离 + 当前窗口的高度）则防止扩张的时候超出范围
                obj1.style.height = _ih - '2' + 'px'; //赋予值

            }
            if (str == "leftBottom") {
                var _iw = _iparentwidth - _iL; // 窗体改变前的宽度 减去 窗体拉伸的长度  
                obj1.style.left = _iparentleft + _iL + 'px'; //当前窗口距离可视窗口左部的距离 + 窗体要移动的距离 (通常为负数)
                var _ih = _iT + _iparentheight; //获取拉伸后窗体改变的高度
                if (_iw < _dragMinWidth) {//之前定义了一个属性值宽度防止小于窗体宽度
                    var _bl = _iw; //赋予值
                    _iw = _dragMinWidth; //赋予值
                    obj1.style.left = (_iparentleft + _iL) - (_dragMinWidth - _bl) + 'px'; //（之前距离左边的距离 + 要添加的x值） - （之前设置的最小宽度值 - 获取拉伸后窗体改变的宽度）
                } else if (_iw > (_iparentleft + _iparentwidth)) {
                    _iw = (_iparentleft + _iparentwidth)
                }; //如果改变后的宽度超过当前窗口距离可视窗口左部的距离 + 窗体改变前的宽度则
                obj1.style.width = _iw - '2' + 'px';  //赋予值
                if (_ih < _dragMinHeight) {//之前定义了一个属性值高度防止小于窗体高度
                    _ih = _dragMinHeight; //赋予值
                } else if (_ih > _maxh) {
                    _ih = _maxh;
                }; //防止扩张的时候超出向下扩张最大高度
                obj1.style.height = _ih - '2' + 'px'; //赋予值

            }
            if (((str == 'left' || str == 'leftTop' || str == 'leftBottom') && _iw == _dragMinWidth) || ((str == 'top' || str == 'rightTop' || str == 'leftTop') && _ih == _dragMinHeight)) {
                document.onmousemove = null;
            }; //是为了当使用时拉伸时不会低于最小值

            return false;

        },
        "mouseup": function () {//拉伸结束
            document.onmousemove = null;
            document.onmouseup = null;
            if ($("#U_UF_F_drag_flag")[0]) {
                U.selectEl("#U_UF_F_drag_flag").remove();
            }
            U.selectEl(document.body).unbind(_windowfun);
        }
    }
    U.selectEl(document.body).bind(_windowfun);
}

//#endregion

//#region 拖动窗体

/*
* 函数功能：元素拖动函数，初始化函数
*
* @param  el1 {element} 触发拖拽的对象元素
* @param  el2 {element} 被拖拽的对象元素
* @param  cb1  {function} 每次拖动时，触发的回调函数
* @param  cb2  {function} 拖动完毕时，触发的回调函数
*/
U.UF.F.drag = function (el, cb1, cb2) {
    /*
    * _x {number} 记录元素的left值距离屏幕的差距
    * _y {number} 记录元素的top值距离屏幕的差距
    * _drag {element} 被拖拽的对象元素
    * */
    var _x, _y, _l, _t, _drag;
    var _event = event || window.event;  //var _event = event || window.event;这句话就是定义了一个变量来获取事件对象，因为不同的浏览器获取事件对象的方法有点不太一样，IE下是window.event，标准下是event，为了兼容所以写了event || window.event.
    /*
    * 说明：
    * _event {element} 事件源
    * _x {element} 记录元素的left值距离屏幕的差距
    * _y {element} 记录元素的top值距离屏幕的差距
    * */
    _drag = el; //赋值被拖拽的对象元素

    _x = _event.clientX; //记录元素的left值距离屏幕的差距
    _y = _event.clientY; //记录元素的top值距离屏幕的差距
    _l = _drag.offsetLeft; //元素的左偏移
    _t = _drag.offsetTop; //元素的右偏移

    /*
    * 说明：对document树，进行事件的绑定。
    * */
    var _windowfun = {
        /*
        * 说明：绑定鼠标移动事件
        * _event {element} 事件源
        * */
        "mousemove": function (event) {
            //如果被拖拽的对象存在，执行以下代码
            if (_drag) {
                /*
                * 说明：变量说明
                * _event {element} 事件源
                * _left  {number} 元素水平移动的距离
                * _top   {number} 元素垂直移动的距离
                * body   {element} 页面body对象
                * */
                var _event = event || window.event, //var _event = event || window.event;这句话就是定义了一个变量来获取事件对象，因为不同的浏览器获取事件对象的方法有点不太一样，IE下是window.event，标准下是event，为了兼容所以写了event || window.event.
                    _newx = _event.clientX - _x,
                    _newy = _event.clientY - _y,
                    _left = _newx + _l, // 移动后鼠标的水平距离减去元素未移动时的水平距离，等到元素水平移动的距离。
                    _top = _newy + _t, // 移动后鼠标的垂直距离减去元素未移动时的垂直距离，等到元素垂直移动的距离。 
                    _body = U.selectEl(document.body)[0]; //页面body对象，用于判断是否超出屏幕可视区域
                //                if (_left < 0) _left = 0; //如果元素水平移动超出屏幕最左侧，则使元素水平距离在屏幕的最左侧
                //                if (_left > _body.offsetWidth - _drag.offsetWidth) _left = _body.offsetWidth - _drag.offsetWidth; //如果元素水平移动超出屏幕最右侧，则使元素水平距离在屏幕的最右侧
                //                if (_top < 0) _top = 0; //如果元素垂直移动超出屏幕最上侧，则使元素垂直距离在屏幕的最上侧
                //                if (_top > (_body.offsetHeight - _drag.offsetHeight)) _top = (_body.offsetHeight - _drag.offsetHeight); //如果元素垂直移动超出屏幕最下侧，则使元素垂直距离在屏幕的最下侧
                //                _drag.style.cursor = 'move'; //改变被拖拽的对象元素的鼠标形状
                _drag.style.left = _left + 'px'; //改变被拖拽的对象元素的水平位置
                _drag.style.top = _top + 'px'; //变被拖拽的对象元素的垂直位置
                if (!$("#U_UF_F_drag_flag")[0] && (_newx != 0 || _newy != 0)) {
                    var _div = $$("div", { "style": { "cssText": "width: 100%;height: 100%;z-index: 99999;position: absolute;top:0;left:0;" }, "id": "U_UF_F_drag_flag" }, document.body);
                }
                if (cb1 && typeof cb1 == "function" && _newx != 0 && _newy != 0) { cb1(); } //如果有拖动时的回调函数，则执行回调函数。
            }
        },
        /*
        * 说明：绑定松开鼠标事件
        * event {element} 事件源
        * */
        "mouseup": function (event) {
            //如果有拖动完成的回调函数，则执行回调函数。
            if (_drag && cb2 && typeof cb2 == "function") { cb2(el) };
            if ($("#U_UF_F_drag_flag")[0]) {
                U.selectEl("#U_UF_F_drag_flag").remove();
            }
            //清空被拖拽的对象元素
            _drag = null;
            U.selectEl(document.body).unbind(_windowfun);
        }
    }
    U.selectEl(document.body).bind(_windowfun);
}

//#endregion

//#region 拖动选择元素 暂未修改

/*
* 选取元素带虚拟框 一般常用于选取元素
*
* @param  {element} 拖动元素
*/
U.UF.F.dragSelect = function (el, fun) {
    //右键处理
    if (event.button != 2) {
        var _x,
            _y,
            _dragel,
            _mousep = U.UF.EL.getMousePosition(el), //鼠标位置
            _record = { x: _mousep.x, y: _mousep.y },
            //拖动函数的处理
            _mousemove = function () {
                //拖动的处理
                U.UF.F.dragSelect.drag(el, _mousep, _dragel, fun, _record);
            },
            //拖动释放的处理
            _mouseup = function () {
                U.selectEl(_dragel).remove();
                //释放取消绑定的处理
                U.selectEl(document).unbind({
                    "mousemove": _mousemove,
                    "mouseup": _mouseup

                });
                U.selectEl(el).unbind({
                    "scroll": _mousemove
                });
            };
        //记录滚动条位置
        _mousep.left = el.scrollLeft;
        _mousep.top = el.scrollTop;
        _x = _mousep.x; //鼠标的x轴坐标
        _y = _mousep.y; //鼠标的y轴坐标
        //创建选择元素
        _dragel = $$("div", { "style": { "cssText": "position:absolute;width:0;height:0;font-size:0;margin:0;padding:0;border:1px solid #89b1e6;background-color:#c3d5ed;z-index:1000;filter:alpha(opacity:60);opacity:.6;background-image: url(/img/UXZT.png); display: inline-block; z-index: 1000; zoom: 1;" + "top:" + _y + "px;left:" + _x + "px;zIndex:" + US.ZINDEX + 1 } }, el);
        //绑定元素的处理
        U.selectEl(document).bind({
            "mousemove": _mousemove,
            "mouseup": _mouseup
        });
        U.selectEl(el).bind({
            "scroll": _mousemove
        });
    }
    else {
        if (el.dragel) {
            el.dragel = null;
        }
    }
}

/*
* 直接拖动元素不带虚拟框 一般常用于图标移动
*
* @param  {element} 拖动元素
*/
U.UF.F.dragSelect.drag = function (el, mouseup, dragel, fun, record) {
    var _m = event.type == "scroll" ? record : U.UF.EL.getMousePosition(el), //当前鼠标的位置 
        _left = mouseup.x + mouseup.left, //滚动条left
        _top = mouseup.y + mouseup.top, //滚动条top
        _ctop = _m.y + el.scrollTop,
        _cleft = _m.x + el.scrollLeft,
        _w = Math.abs(_cleft - _left), //拖动后的长
        _h = Math.abs(_ctop - _top), //拖动后的宽
        _l = Math.min(_cleft, _left), //拖动后的left
        _t = Math.min(_ctop, _top)    //拖动后的top
        ;
    //如果是滚动出发的则找不到鼠标的位置 所以需要通过记录去找
    record.x = _m.x;
    record.y = _m.y;
    //拉动大小变化 
    U.selectEl(dragel).addAttrArray({ "style": { "cssText": "width:" + _w + "px;height:" + _h + "px;top:" + _t + "px;left:" + _l + "px;" } });
    //设置拉伸选取的处理
    U.UF.F.dragSelect.isLocation(dragel, el, { "width": _w, "height": _h, "left": _l, "top": _t }, fun);
}

/*
* 选择元素逻辑范围逻辑
*
* @param  {object} 选择的范围
*/
U.UF.F.dragSelect.isLocation = function (dragel, el, obj, fun) {
    var i,
        _left,
        _top,
        _width,
        _height,
        _arr = [],
        _child = U.selectEl(el).Child() //所有的拖选取的元素
        ;
    //循环子元素的处理
    for (i = 0; i < _child.length; i++) {
        //处理的元素不是拖选元素
        if (_child[i] != dragel) {
            _left = _child[i].offsetLeft;
            _top = _child[i].offsetTop;
            _width = _child[i].offsetWidth;
            _height = _child[i].offsetHeight;
            //范围判断
            if ((obj.left < _left + _width && obj.left + obj.width > _left) && (obj.top < _top + _height && obj.top + obj.height > _top)) {
                _arr.push(_child[i]);
            }
        }
    }
    //回调处理
    if (fun) {
        fun(_arr);
    }
}


///*
//* 获取元素选择范围
//*
//* @param  {object} 选择的范围
//*/
//U.UF.F.dragSelect.getElementRange = function (el, obj) {//
//    //    var _UL, _UDE = [0, 0];
//    //    _UDE[4] = _UL = Math.floor(this.ElO["SW"] / this.W); //每行占位的个数
//    //    _UDE[0] = ((Math.floor(ULE["Y"] / this.H) - 1) * _UL); //开始的位置
//    //    _UDE[1] = _UDE[0] + ((Math.ceil((ULE["BY"]) / this.H) - Math.floor(_UDE[0] / _UL)) * _UL); //结束的位置
//    //    _UDE[2] = Math.min(Math.ceil(ULE["X"] / this.W), _UL) - 1; _UDE[3] = Math.min(Math.ceil(ULE["BX"] / this.W), _UL) - 1; return _UDE;
//}


//#endregion

//#region 拖拉变化

///*
//* 获取元素选择范围
//*
//* @param  {object} 拖选的元素
//* @param  {object} 拖选的传参
//*/
//U.UF.F.dragTable = function (el, obj) {
//    if (el) {
//        obj = obj || {};
//        new U.UF.F.dragTable.init(el, obj); //初始化拖选
//    }
//}

///*
//* 拖动初始化
//*
//* @param  {object} 拖选的元素
//* @param  {object} 拖选的传参
//*/
//U.UF.F.dragTable.init = function (el, obj) {
//    var _UDTD = U.selectEl(el),
//    _UDSD = _UDTD.parentElement(), //上级元素
//    _UDPD = _UDTD.prev(), //上面的兄弟节点
//    _UDND = _UDTD.next(); //下面的兄弟节点
//    //添加初始化值
//    this.UDPD = _UDSD; //上级元素
//    this.w = _UDSD.width(); //当前长度
//    this.pw = _UDSD.parentElement().width(); //总长度
//    this.el = el; //拖动的元素
//    this.UE = U.UF.EL.getMousePosition(); //鼠标的位置
//    this.prev = _UDPD; //上面的兄弟节点
//    this.next = _UDND; //下面的兄弟节点
//    this.uw = [_UDPD.width(), _UDND.width()]; //兄弟节点长度

//    //拖动参数设置
//    U.UF.C.AddObj(this, obj);
//    //聚焦
//    el.setCapture();
//    //拖动元素
//    U.selectEl(document.body).bind({
//        "mousemove": (this.move = U.UF.C.apply(this, obj.tf ? this.dragB : this.drag)),
//        "mouseup": (this.mup = function () { this.up(); })
//    });
//}

//U.UF.F.dragTable.init.prototype = {
//    //拖动左右使用
//    drag: function () {
//        var _UDVD = this.prev, //上级元素
//        _UDND = this.next, //下面的兄弟节点
//        _UW = this.uw, //不变的大小
//        _UE = this.UE, //鼠标的位置
//        _UME = U.UF.EL.getMousePosition(); //当前处理的鼠标位置
//        _UME["X"] = Math.min(Math.max(-_UW[0], _UME["X"] - _UE["X"]), _UW[1]); _UDVD.css("width", _UW[0] + _UME["X"] + "px"); _UDND.css("width", _UW[1] + _UME["X"] + "px"); //拖动大小处理
//        if (this.scb) { this.scb() }; //拖动回调
//    },
//    //拖动菜单
//    dragB: function () {
//        var _UW,
//        _UDPD = this.UDPD, //上级元素
//        _UDSD = this.prev, //上级元素
//        _UPW = this.pw, //总长度
//        _UW = this.uw[0], //上面兄弟节点的长度
//        _UE = this.UE, //鼠标的位置
//        _UME = U.UF.EL.getMousePosition(); //鼠标位置
//        _UME["X"] = Math.max(-_UW, _UME["X"] - _UE["X"]); //获取left
//        _UDSD.css("width", _UW + _UME["X"] + "px"); //设置下级兄弟的长度
//        _UDPD.css("width", (_UW = (_UME["X"] + this.w)) > this.pw ? _UW + "px" : this.pw + "px"); //设置上级兄弟的长度
//        if (this.scb) { this.scb() };
//    },
//    //拖动释放
//    up: function () {
//        this.el.releaseCapture(); //释放聚焦
//        U.selectEl(document.body).unbind({ "mousemove": this.move, "mouseup": this.mup }); //释放拖动绑定
//        if (this.upcb) { this.upcb() }; //回调处理
//    }
//}
//#endregion