/*
此处的命名空间和U.DD.js相同 因为功能是属于一个模块下的
*/

//#region 拖动区域
Namespace.register("U.D");

//#region 带虚拟框的拖动
/*
* 拖动函数处理
*
* @param  {element} 需要拖动的元素
* @param  {function} 拖动回调函数
* @param  {object} 拖动参数
----------参数为GetElementInfo 返回值
* @return  {object} 拖动对象
*/
U.D.DragMouseDown = function (UDOD, UCB, UDE) {
    if (event.button < 2) { //判断左键使用
        var _UTE = new U.D.DragMouseDown.init(UDOD, UCB, UDE),
        _UKE = {//拖动事件处理
            "mousemove": U.M.apply(_UTE, _UTE.Drag), //move事件处理
            "mouseup": U.M.apply(_UTE, _UTE.DragUp) //up事件处理
        };
        //绑定事件
        U.Ut.AddObj(_UTE, _UKE); //给拖动方法添加新的事件。
        _UTE.create(); //创建拖动参数
        $(document).bind(_UKE); //绑定拖动事件
        //返回对象
        return (U.D.DragMouseDown.ST = _UTE);
    }
}

/*
* 初始化拖动等待拖动
*
* @param  {element} 需要拖动的元素
* @param  {function} 拉伸回调函数
* @param  {object} 拖动参数
* @param  {object} 拉伸回调函数
----------参数为GetElementInfo 返回值
*/
U.D.DragMouseDown.init = function (UDOD, UCB, UDE, UCE) {

    (UCE && UCE.start) && (UCE.start()); //初始化回调
    this.set(UCE);
    //参数设置和说明
    this.set({
        max: (UDE && UDE.MaxLeft) ? UDE : null, //最大的拖动范围
        SO: UDOD, //拖动的元素
        AF: UCB, //回调函数
        ESO: event.srcElement //当前选中的元素
    });
    return this;
}

U.D.DragMouseDown.init.prototype = {
    /*
    * 设置拖动参数 上述有参数说明
    *
    * @param  {object} 需要拖动的元素
    */
    set: function (UDE) {
        (UDE) && (U.Ut.AddObj(this, UDE));
    },
    /*
    * 创建虚拟框
    *
    */
    create: function () {
        var _UDOD = this.SO, //拖动元素
        _UHE = U.M.GetElementAllInfo(_UDOD); //拖动元素的位置
        //参数设置
        U.Ut.AddObj(this, {
            IsD: false, //是否为有效拖动
            XY: U.M.GetMousep(), //当前鼠标位置
            E: _UHE, //拖动元素大小等
            MaxTop: _UHE["PXT"] + US.Height - 10, //最大拖动top
            MaxLeft: _UHE["PXL"] + US.Width, //最大拖动left
            MinLeft: -_UHE["OW"] + 10, //最小拖动left
            MinTop: 0 //最小拖动top
        });
        //判断是否有最大范围设置
        (this.max) && (this.IsMinAndMax());
    },
    /*
    * 限制拖动范围
    *
    * @param  {object} 需要拖动的元素
    */
    IsMinAndMax: function (UDE) {
        U.Ut.AddObj(this,
        { "MaxLeft": this.E["PXL"] + UDE["MaxLeft"] || this.MaxLeft, //最大拖动left
            "MinLeft": UDE["MinLeft"] || this.MinLeft, //最小拖动left
            "MinTop": UDE["MinTop"] || this.MinTop, //最小拖动top
            "MaxTop": this.E["PXT"] + UDE["MaxTop"] || this.MaxTop //最大拖动top
        }); //设置拉伸的范围限制
    },
    //拖动时触发的函数
    Drag: function () {
        var i, _UHE, _UDTD, _UDMD,
        _UDOD = this.SO, //拖动元素
        _UDE = [["X", "Left", "L"], ["Y", "Top", "T"]],  //设置参数
        _UME = this.E, //拖动元素原大小位置
        _UCE = this.XY,
        _UE = U.M.GetMousep(); //鼠标的位置
        (this.move) && (this.move(this)); //回调函数
        //循环判断设置 top left
        for (i = 0; i < _UDE.length; i++) {
            _UDE[i] = Math.min(Math.max(_UE[(_UHE = _UDE[i])[0]] - _UCE[_UHE[0]] + _UME["O" + _UHE[2]], this["Min" + _UHE[1]]), this["Max" + _UHE[1]]);
        }
        //第一次拖动的参数
        if (!this.IsD) {
            this.IsD = true; //设置正在拖动
            U.Ut.AddObj(this, {
                VDB: U.D.foundVirtualBox(_UDOD), //添加虚拟框
                UMD: U.D.Masklayer() //添加遮层
            });
            //绑定事件
            $(this.UMD).bind({
                mousemove: this.mousemove, //移动事件绑定
                mouseup: this.mouseup //释放事件
            });
            //遮罩置顶
            U.D.SetDTop(this.UMD);
            U.D.SetDTop(this.VDB);
            //鼠标聚焦处理
            this.VDB.setCapture();
        }
        //鼠标处理
        $(this.VDB).addAttrArray({ "style": { "cssText": "left:" + _UDE[0] + "px;top:" + _UDE[1] + "px;"} });
    },
    //拖动结束
    DragUp: function () {
        //事件释放
        $[document, this.UMD].unbind(
        {
            "mousemove": this.mousemove, //拖动变化使用
            "mouseup": this.mouseup //拖动结束
        });
        this.IsD = false; //设置结束
        //释放元素 同时元素定位
        if (this.VDB) {
            var _UDMD = this.UMD, //遮罩框
            _UDTD = this.VDB, //虚拟框
            _UDE = U.M.GetElementInfo(_UDTD); //拖动结束的位置
            _UDTD.releaseCapture();
            U.D.DragMouseDown.chche = U.D.DragMouseDown.ST = null;
            $[_UDMD, this.VDB].remove(); //元素移除 //事件结束
            $(this.SO).addAttrArray({ "style": { "cssText": "top:" + (_UDE["OT"] + 2) + "px;left:" + (_UDE["OL"] + 2) + "px;"} });
            U.D.withf(this.UCB); //执行回调
        }
    }
}

//#endregion

//#region

/*
* 直接拖动元素不带虚拟框 一般常用于图标移动
*
* @param  {element} 需要拖动的元素
* @param  {object} 拖动参数
----------[ST] 初始化回调函数
* @return  {object} 拖动对象
*/
U.D.iconmove = function (UDOD, UDE) {
    if (event.button != 2) { //只有右键允许拖动
        var _UTE = new U.D.iconmove.init(UDOD, UDE);
        return _UTE;
    }
}

U.D.iconmove.init = function (UDOD, UDE) { //拖动开始
    if (UDOD) {
        var i, _UE = U.M.GetElementAllInfo($(UDOD)[0]), //拖动元素的位置
        _UKE = U.M.GetMousep(), //鼠标位置
        _UCE = this.UCE = {
            "mousemove": U.M.apply(this, this.move), //移动函数处理
            "mouseup": U.M.apply(this, this.up) //释放函数处理
        };
        (UDE && UDE["ST"]) && (UDE["ST"].call(this, UDOD)); //初始化回调
        //初始化参数
        U.Ut.AddObj(this, {
            IsD: false, //设置未拖动状态
            //  UMD: U.D.Masklayer(), //虚拟框
            E: _UKE, //鼠标位置
            SO: UDOD, //拖动元素
            UE: _UE, //元素的位置
            UCF: UDE, //拖动传参
            MT: _UE["PXT"] + US.Height - 10, //拖动最大top
            ML: _UE["PXL"] + US.Width, MIL: -_UE["OW"] + 10, //拖动最大left
            MIT: 0 //最小拖动范围
        });
        //绑定设置
        UDOD.setCapture(); //事件聚焦
        $(document).bind(_UCE); //事件绑定 
        U.D.SetDTop(this.UMD, true); //置顶
        $(UDOD).css("z-index", 9999); //当前拖动元素置顶
        return this;
    }
}

U.D.iconmove.init.prototype = {
    //移动效果
    move: function () {
        var i, _UTL,
        _UDOD = this.SO; //当前拖动元素处理
        _UE = U.M.GetMousep(),  //当前拖动鼠标位置
        _UKE = this.E, //初始鼠标位置
        _UME = this.UE, //元素位置
        _UAE = [["X", "L"], ["Y", "T"]]; //变化top left对应参数
        U.M.StopBubble(); //阻止冒泡
        if (!this.UMD) {
            this.UMD = U.D.Masklayer();
            $(this.UMD).bind(this.UCE); //事件绑定 
        }
        //计算获取位置
        for (i = 0; i < _UAE.length; i++) {
            _UTL = _UE[_UAE[i][0]] - _UKE[_UAE[i][0]];
            (Math.abs(_UTL) > 2) && (this.IsD = true);
            _UAE[i] = Math.min(Math.max(_UTL + _UME["O" + _UAE[i][1]], this["MI" + _UAE[i][1]]), this["M" + _UAE[i][1]]);
        }
        //设置值
        $(_UDOD).addAttrArray({ "style": { "cssText": "left:" + _UAE[0] + "px;top:" + _UAE[1] + "px"} }); //?
        (this.UCF && this.UCF["Move"]) && (this.UCF["Move"].apply(this, [_UDOD, _UAE, _UKE, _UE])); //回调
        this.ism = true;
    },
    //移动结束
    up: function () {
        var _UDOD = this.SO, //拖动元素
            _UFE = this.UCF; //回调函数
        U.M.StopBubble(); //阻止冒泡
        _UDOD.setCapture(); //事件聚焦
        //释放
        this.ism = null;
        $(this.UMD).remove(); //虚拟框移除
        $(document).unbind(this.UCE); //移除绑定
        $(_UDOD).css("z-index", ""); //去除置顶
        //        //回调
        (_UFE && _UFE["UP"]) && (_UFE["UP"].apply(this, [_UDOD])); //回调函数处理
        setTimeout(function () { _UDOD.releaseCapture() }, 0); ; //鼠标聚焦移除
    }
}

//#endregion

//#region 拖动选择区域

/*
* 直接拖动元素不带虚拟框 一般常用于图标移动
*
* @param  {object} 拖动参数
*/
U.D.DragSelectE = function (UDE) {
    if (event.button != 2) {
        var _UTE, _UCE, _UKE,
        _UDOD = UDE["SO"], //拖选区域的元素
        _UE = U.M.GetMousep(), //获取当前鼠标的位置
        _UTF = _UDOD.componentFromPoint(_UE["X"] + 2, _UE["Y"] + 2);
        //在滚动条内允许使用
        if (_UTF != "outside" && _UTF.indexOf("scroll") == -1) {
            _UTE = (new U.D.DragSelectE.init(UDE)).create().SetHover().event();
            return _UTE;
        }
    }
    else { //右键处理
        (U.D.DragE) && (U.D.DragE.SetHover());
    }
}

/*
* 拖动开始区域
*
* @param  {object} 拖动参数
*/
U.D.DragSelectE.init = function (UDE) {
    var _UDOD = UDE["SO"],
    _UDTD = UDE["SSO"] || _UDOD,
    _USC = UDE["CS"];
    //拖动参数添加
    U.Ut.AddObj(this, {
        "EL": _UDOD,
        "SSO": _UDTD,
        "OS": _UDTD.onscroll,
        "CB": _UDOD.onmousedown,
        "CS": _USC,
        "PEL": U.M.GetStyle(_UDOD, "position") != "static" ? _UDOD : U.M.TOSP(_UDOD), "TC": [],
        "Fun": UDE["FUN"],
        "ElO": "",
        "ESO": "",
        "UT": "",
        "UL": "",
        "UW": "",
        "UH": "",
        "X": "",
        "Y": "",
        "TX": "",
        "TY": "",
        "PUX": "",
        "PUY": "",
        "W": "",
        "H": "",
        "T": "",
        "L": ""
    });
}

U.D.DragSelectE.init.prototype = {
    event: function (UTF) { //事件赋值
        var i, j, k, z, _USH, _UKE,
        //拖选处理 绑定4个时间 mousedown mousemove mouseup scroll
        _UCE = this.e = this.e || [[document, { "mousemove": ["Drag"], "mouseup": ["DragUp"]}], [this.SSO, { "scroll": ["CTA", "Drag"]}], [this["EL"], { "mousedown": ["Event"]}]];
        //拖选处理
        for (i = 0; i < _UCE.length; i++) {
            _UKE = _UCE[i]; (!U.Ut.isArray(_UKE[0])) && (_UKE[0] = [_UKE[0]]);
            //绑定事件处理
            for (j in _UKE[1]) {
                if (_UKE[1].hasOwnProperty(j)) {
                    for (k = 0; k < _UKE[1][j].length; k++) { //绑定解除
                        (U.Ut.isString(_UKE[1][j][k])) && (_UKE[1][j][k] = U.M.apply(this, [[this[_UKE[1][j][k]]]])); //设置函数
                        for (z = 0; z < _UKE[0].length; z++) {
                            $(_UKE[0][z])[(UTF ? "un" : "") + "bind"](j, _UKE[1][j][k]);
                        }
                    }
                }
            }
        }
    },
    //变化赋值
    CTA: function () {
        var _UXE = this.ElO = U.M.GetElementAllInfo(this.EL),  //元素位置大小
        //设置元素的位置
        _UAE = {
            "PUX": this["PUX"],
            "PUY": this["PUY"]
        };
        //元素位置设置
        U.Ut.AddObj(this, { "PUX": _UXE["SL"] + _UXE["PXL"], "PUY": _UXE["ST"] + _UXE["PXT"] });
        if (_UAE["PUX"] !== "") {
            this.DBH({
                "UW": this.UW + (this["PUX"] - _UAE["PUX"]),
                "UH": this.UH + (this["PUY"] - _UAE["PUY"]),
                "UT": this.UT, "UL": this.UL
            });
        }
        return _UXE;
    },
    //创建托选
    create: function () {
        var i, _UKE, _UDTD,
        _UDOD = this.EL, //拖动的元素
        _UE = U.M.GetMousep(), //鼠标位置
        _UXE = this.CTA(); //获取大小和变量
        /*
        设置大小位置
        C:拖选下的志愿时 TX：left TY：top
        */
        U.Ut.AddObj(this, {
            "C": $(_UDOD).Child(),
            "TX": _UXE.TX,
            "TY": _UXE.TY,
            "X": _UE.X - _UXE.TX + this["PUX"],
            "Y": _UE.Y - _UXE.TY + this["PUY"]
        });
        //允许拖选使用
        if ((_UDTD = this.C[0])) {
            _UKE = ["Left", "Top", "Right", "Bottom"];
            for (i = 0; i < _UKE.length; i++) {
                _UKE[i] = U.M.GetStyle(_UDTD, "margin" + _UKE[i]); _UKE[i] = (!_UKE[i] || _UKE[i] == "auto") ? 0 : parseInt(_UKE[i]);
            }
            /*
            参数设置：
            W:拖选长 H:拖选宽 T：拖动的高度 L：拖动的left
            */
            U.Ut.AddObj(this, {
                "W": _UDTD.offsetWidth + _UKE[0] + _UKE[2],
                "H": _UDTD.offsetHeight + _UKE[1] + _UKE[3],
                "T": _UKE[1] + _UKE[3],
                "L": _UKE[0] + _UKE[2]
            });
        }
        //拖动元素
        this.ESO = $$("div", { "className": "UD_DSE", "style": { "cssText": "top:" + this.Y + "px;left:" + this.X + "px;zIndex:" + US.ZV + 1} }, _UDOD);
        return this;
    },
    Drag: function () {//拖动选择逻辑
        var _UDOD = this.EL,
        _UE = U.M.GetMousep(), //当前鼠标的位置获取
        _UT = Math.min(Math.max(_UE["Y"] - this.TY + this["PUY"], 0), Math.max(this.ElO["SH"], this.ElO["OH"]) - 2), //top
        _UL = Math.min(Math.max(_UE["X"] - this.TX + this["PUX"], 0), this.ElO["SW"] - 2), //left
        _UW = _UL - this.X, //选择的长
        _UH = _UT - this.Y; //选择的框
        //设置拖动最大最小的范围
        if (_UW < 0) { _UW = Math.abs(_UW); }
        else { _UL = this.X; }
        if (_UH < 0) { _UH = Math.abs(_UH); }
        else { _UT = this.Y; } //设置位置和大小
        this.DBH({
            "UW": _UW,
            "UH": _UH,
            "UT": _UT,
            "UL": _UL
        }); //设置大小位置
    },
    /*
    * 滚动大小变化设置
    *
    * @param  {object} 选择的范围
    */
    DBH: function (UDE) {
        var _UE = {};
        $(this.ESO).addAttrArray({ "style": { "cssText": "width:" + UDE.UW + "px;height:" + UDE.UH + "px;top:" + UDE.UT + "px;left:" + UDE.UL + "px;"} }); //拉动大小变化 
        U.Ut.AddObj(this, UDE); //添加属性处理

        //位置大小设置
        U.Ut.AddObj(_UE, {
            "X": UDE.UL,
            "Y": UDE.UT,
            "BX": UDE.UW + UDE.UL,
            "BY": UDE.UH + UDE.UT
        });
        this.IsLocation(_UE); //位置大小设置
    },
    /*
    * 选择元素逻辑范围逻辑
    *
    * @param  {object} 选择的范围
    */
    IsLocation: function (UDE) {
        if (this.C[0]) {//有子元素
            var i, _UKE, _UDTD, _UTF,
            _ULE = this.GetLXY(UDE); //选择的元素

            //去除样式
            if (this.TC.length) {
                for (i = 0; i < this.TC.length; i++) {
                    $(_UDTD).removeClass(this.CS);
                }
            }

            //重新生成选择元素
            this.TC = [];
            for (i = _ULE[0]; i < _ULE[1]; i++) {//生成
                if ((_UDTD = this.C[i])) {
                    //计算范围进行判断是否需要选择钙元素
                    _UTF = ((_UKE = i % _ULE[4]) >= _ULE[2]) && (_UKE <= _ULE[3]) && ((_UKE + 1) * this.W >= UDE["X"]);
                    if (_UTF && (_UDTD.offsetTop > UDE["BY"] || (_UDTD.offsetTop + this.H - this.T < UDE.Y))) {
                        _UTF = false;
                    }
                    $(_UDTD)[(_UTF ? "add" : "remove") + "Class"](this.CS); //去除css
                    (_UTF) && (this.TC.push(_UDTD));
                }
            }
            U.D.DragE = this;
        }
    },
    /*
    * 获取元素选择范围
    *
    * @param  {object} 选择的范围
    */
    GetLXY: function (ULE) {//
        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;
    },
    //左右键逻辑
    Event: function () {
        if (event.button == 2) {
            var i, _UHT, _UHL, _UTF,
            _UDCD = this.TC, _UE = U.M.GetMousep(), //鼠标位置
            _UT = _UE["Y"] - this.TY + this["PUY"], //鼠标在滚动掉的top
            _UL = _UE["X"] - this.TX + this["PUX"]; //鼠标在滚动掉的left
            //计算范围
            for (i = 0; i < _UDCD.length; i++) {
                if (((_UHT = _UDCD[i].offsetTop) <= _UT && (_UHT + this.H - this.T) >= _UT) && ((_UHL = _UDCD[i].offsetLeft) <= _UL && (_UHL + this.W) > _UL)) {
                    _UTF = true;
                }
            }
            //如果是需要回调的元素
            if (_UTF) {
                (this.Fun) && (this.Fun(this.TC));
            }
            return !_UTF; //回调使用
        }
    },
    //结束的逻辑
    DragUp: function () {
        var _UDOD = this.EL;
        this.event(true);
        _UDOD.releaseCapture();
        _UDOD.removeChild(this.ESO); //去除事件
    },
    //释放变化
    SetHover: function () {
        var _UTE = U.D.DragE || this;
        (_UTE.TC && _UTE.TC.length) && ($(_UTE.TC).removeClass(this.CS)); //去除选择元素样式
        U.D.DragE = this.TC.length = 0;
        return this;
    }
}

//#endregion

//#region 拖拉变化
/*
* 获取元素选择范围
*
* @param  {object} 拖选的元素
* @param  {object} 拖选的传参
*/
U.D.DragAb = function (UDOD, UDE) {
    if (UDOD) {
        UDE = UDE || {};
        new U.D.DragAb.init(UDOD, UDE); //初始化拖选
    }
}

/*
* 拖动初始化
*
* @param  {object} 拖选的元素
* @param  {object} 拖选的传参
*/
U.D.DragAb.init = function (UDOD, UDE) {
    var _UDTD = $(UDOD),
    _UDSD = _UDTD.parentg(), //上级元素
    _UDPD = _UDTD.prev(), //上面的兄弟节点
    _UDND = _UDTD.next(); //下面的兄弟节点
    //添加初始化值
    U.Ut.AddObj(this, {
        UDPD: _UDSD, //上级元素
        w: _UDSD.width(), //当前长度
        pw: _UDSD.parentg().width(), //总长度
        UDOD: UDOD, //拖动的元素
        UE: U.M.GetMousep(), //鼠标的位置
        prev: _UDPD, //上面的兄弟节点
        next: _UDND, //下面的兄弟节点
        uw: [_UDPD.width(), _UDND.width()] //兄弟节点长度
    });
    //拖动参数设置
    U.Ut.AddObj(this, UDE);
    //聚焦
    UDOD.setCapture();
    //拖动元素
    $(document.body).bind({
        "mousemove": (this.move = U.M.apply(this, UDE.tf ? this.dragB : this.drag)),
        "mouseup": (this.mup = U.M.apply(this, this.up))
    });
}

U.D.DragAb.init.prototype = {
    //拖动左右使用
    drag: function () {
        var _UDVD = this.prev, //上级元素
        _UDND = this.next, //下面的兄弟节点
        _UW = this.uw, //不变的大小
        _UE = this.UE, //鼠标的位置
        _UME = U.M.GetMousep(); //当前处理的鼠标位置
        _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"); //拖动大小处理
        (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.M.GetMousep(); //鼠标位置
        _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"); //设置上级兄弟的长度
        (this.scb) && (this.scb());
    },
    //拖动释放
    up: function () {
        this.UDOD.releaseCapture(); //释放聚焦
        $(document.body).unbind({ "mousemove": this.move, "mouseup": this.mup }); //释放拖动绑定
        (this.upcb) && (this.upcb()); //回调处理
    }
}

//#endregion