CocoRoboDesktop/js/Office/Excel/ExcelRightClick.js

Namespace.register("U.MD.O.E.RC");
/*Excel的右键功能*/

/**
*  添加行功能
*  checkdCell 被选中的最后一个单元格
*  lineNum 行数
*  req 当为true的时候 不发送send请求
*/
U.MD.O.E.RC.addLine = function (checkdCell, lineNum, req) {     //传入参数
    var _excel = U.MD.O.E,                                      //声明变量
        _cellBox = $(".U_MD_O_E_cellBox")[0],                   //获取表格的最大包
        _rBList = U.UF.C.toArray($(".U_MD_O_E_row")),           //所有的行板
        _cBList = U.UF.C.toArray($(".U_MD_O_E_column")),        //所有的列板
        _cellList = U.UF.C.toArray($(".U_MD_O_E_cell")),        //所有的单元格
        _rBBox = $(".U_MD_O_E_rowBoard")[0],                    //行板的父元素
        _cellLast = checkdCell,                                 //被选中单元格中的最后一个
        _rowNum = _cellLast.row,                                //获取最后一个单元格的所在行数   相当于右键单元格当前所在行
        _rBoardCurrent = $(".U_MD_O_E_row")[_rowNum - 1],       //当前选中单元格所对应的行板
        _rBoardNext,                                            //当前单元格下一行所对应的行板
        _rBLen = _rBList.length,                                //为所以的行板的长度
        _rowNext,                                               //当前单元格的下一行的所有元素
        _height,                                                //行板的高
        _top,                                                   //上边距
        _frag = $$("frag"),                                     //声明节点DocumentFragment是一种“轻量级”的文档，可以包含和控制节点，但不会像完整的文档那样占用额外的资源。
        _mergeCellList,                                         //当前单元格以下的所有合并的单元格
        _newEl,                                                 //单元格
        _iRowCell,                                              //第i行的所有单元格
        _colName,                                               //单元格的行的属性名
        _rowName,                                               //单元格的列的属性名
        _newRow,                                                //新添加的行     
        _newrB,                                                 //为被拷贝的行板
        _rowRule,                                               //在单元格指定的元素
        _mergeId,
        _addHeight,                                             //增加的高度
        _mergeChangeArr = [],                                   //为空的数组
        i,                                                      
        j;

    if (_rowNum < _rBLen) {                           //如果选中的行不是最后一行 
        _rBoardNext = $(".U_MD_O_E_row")[_rowNum];    //当前单元格下一行所对应的行板
        _rowNext = _cellList.filter(function (el) {   //当前单元格的下一行的所有元素
            return +(el.row) === (_rowNum + 1);       //返回值
        });
        _height = _rBoardNext.offsetHeight;           //行板的高
        _top = _rBoardNext.offsetTop;                 //行板的offsetTop值 = 单元格的top
    } else {
        _rBoardNext = _rBoardCurrent;                 //当前单元格下一行所对应的行板
        _rowNext = _cellList.filter(function (el) {   //当前选中行的所有单元格
            return +(el.row) === (_rowNum);           //返回值
        });
        _height = _rBoardCurrent.offsetHeight;        //当前选中单元格所对应的行板的高度
        _top = _rBoardCurrent.offsetTop;              //当前选中单元格所对应的行板的上边距
    }
    _addHeight = _height * lineNum;
    _rowNext.forEach(function (el) {                 //for循环遍历当前选中行的所有单元格
        _colName = +(el.col);                        //定义变量里面的内容
        _rowName = +(el.row);                        //定义变量里面的呢绒
        var lineLen;                                 //声明变量
        if (_rowNum < _rBLen) {                      //如果选中的行不是最后一行 
            i = 0;                                   //只遍历到最后一行前面一行
            lineLen = lineNum;
        } else {
            i = 1;
            lineLen = lineNum + 1;                   //只从第二行开始遍历
        }
        var _newEl = el.cloneNode(),                //拷贝循环的结果
            _mergeArr,
            _mergeEl;
        if (el.s_mergerow === _rowName) {         //如果克隆的行数 与最大合并单元格 的行 相同
            _mergeId = el.s_merge;                //获取元素
            _newEl.style.display = "block";       //表示显示
            _newEl.style.height = _height + "px"; //定义高
            _newEl.style.width = _cBList[_colName - 1].offsetWidth + "px";//定义宽
            $(_newEl).eRmAttr("s_mergecol");      //返回指定元素的属性
            $(_newEl).eRmAttr("s_mergerow");
            $(_newEl).eRmAttr("e_mergecol");
            $(_newEl).eRmAttr("e_mergerow");
            $(_newEl).eRmAttr("s_merge");
            $(_newEl).eRmAttr("e_merge");
        }

        if (el.s_merge && _mergeId !== el.s_merge) {        /*合并 且 不是最大的单元格时 _mergeId !== el.s_merge 这句话表示一个大单元格只修改一次属性 */
            _mergeId = el.s_merge;                          //声明变量
            _mergeEl = $("#" + _mergeId)[0];                //根据参数选择一个对象
            _mergeEl.style.height = _mergeEl.offsetHeight + _addHeight + "px";//定义高

            _mergeArr = _cellList.filter(function (el) {    //修改合并单元格的 结束位置
                return el.s_merge === _mergeId;
            });
            _mergeArr.forEach(function (el) {               //for循环遍历一开始拷贝的结果
                $(el).eAttr("e_mergerow", el.e_mergerow + lineNum);//返回值
                $(el).eAttr("e_merge", "POS_" + el.e_mergecol + "_" + el.e_mergerow);
            });

            var temp = {
                col: el.s_mergecol,
                row: el.s_mergerow                          //定义数组
            };
            _mergeChangeArr.push(temp);                     //调用函数
        }
        for (; i < lineLen; i++) {                          //此处添加新的列榜
            _newEl = _newEl.cloneNode();                    //声明变量为拷贝的对象
            if (el.s_merge && el.s_mergerow !== _rowName) {    //如果克隆的是非最大单元格的元素 
                $(_newEl).eAttr("s_merge", el.s_merge);
                $(_newEl).eAttr("s_mergerow", el.s_mergerow);
                $(_newEl).eAttr("s_mergecol", el.s_mergecol);
                $(_newEl).eAttr("e_mergerow", el.e_mergerow);
                $(_newEl).eAttr("e_mergecol", el.e_mergecol);
                $(_newEl).eAttr("e_merge", "POS_" + _newEl.e_mergecol + "_" + _newEl.e_mergerow);//返回值
            }
            _newEl.style.top = _top + _height * i + "px"; //此处为单元格上边距
            _newRow = _rowName + i;                       //赋值
            $(_newEl).eAttr("row", _newRow);             //返回值
            _newEl.col = _colName;
            _newEl.id = "POS_" + _colName + "_" + _newRow;
            U.MD.O.E.BC.Focus(_newEl);  //添加单元格聚焦事件
            U.MD.O.E.BC.dragCheckd(_newEl); //添加拖拽选中事件
            _frag.appendChild(_newEl);//生成子节点
        }
    });

    for (i = 0; i < lineNum; i++) {     //此处为添加新的行榜
        _newrB = _rBoardNext.cloneNode(true); //声明变量为拷贝的对象，返回正确
        _newrB.firstChild.textContent = +(_rBoardCurrent.innerText) + 1;//定义第一个子节点
        $(_newrB).eAttr("rowname", +(_rBoardCurrent.innerText) + 1);//返回值
        _rowRule = $(_newrB).find(".U_MD_O_E_rowRule");//在单元格里面指定元素
        U.MD.O.E.BC.rowExpanding(_rowRule);
        U.MD.O.E.BC.rBoardChecked(_newrB); //添加点击 拖拽功能
        _excel.After(_rBoardCurrent, _newrB);//返回值
        _rBoardCurrent = _newrB;
    };

    for (i = _rowNum + 1; i <= _rBLen; i++) {      //此处是操作单元格的 使选中行下面的所有行移动位置 与 属性
        _rBList[i - 1].firstChild.textContent = i + lineNum; //定义第一个子节点
        $(_rBList[i - 1]).eAttr("rowname", i + lineNum)
        _iRowCell = _cellList.filter(function (el) {    //第i行的所有单元格
            return (+(el.row) === i && (el.parentNode.nodeType !== 11)); //返回值第i行的所有单元格
        });
        _top = _rBList[i - 1].offsetTop;//声明上边距
        _iRowCell.forEach(function (el) {//for循环遍历
            _frag.appendChild(el);       //查找子节点
            el.style.top = _top + "px";  //赋值上边距
            _colName = el.col;           //指定参数
            _newRow = +(i + lineNum);
            el.id = "POS_" + _colName + "_" + _newRow;//赋值ID
            $(el).eAttr("row", _newRow);
        })
    }

    _cellBox.appendChild(_frag);

    _mergeCellList = _cellList.filter(function (el) {   //获取当前单元格以下的所有合并的单元格
        return +(el.s_mergerow) > _rowNum;
    });

    _mergeCellList.forEach(function (el) {      /*此处为 修改该行下的 所有合并 单元格的 信息*/
        $(el).eAttr("s_mergerow", el.s_mergerow + lineNum);
        $(el).eAttr("e_mergerow", el.e_mergerow + lineNum);
        $(el).eAttr("s_merge", "POS_" + el.s_mergecol + "_" + el.s_mergerow);
        $(el).eAttr("e_merge", "POS_" + el.e_mergecol + "_" + el.e_mergerow);
    });
    var _data = {
        start: _rowNum,    //第几行开始
        lineNum: lineNum,        //添加几行
        sizeChange: (_rBoardNext.offsetHeight === U.MD.O.E.rowBoardHeight ? false : _rBoardNext.offsetHeight),       //如果高度等于单元格初始化高度(40) 则为false  否则将高度存起来
        mergeArr: _mergeChangeArr    //需要修改被合并单元格的元素 的 信息
    };

    U.MD.O.E.dataChange(U.MD.O.E.excelInfo("addLine", _data), req);
}

/**
*  删除行
*  startCell 选中的第一个单元格
*  endCell 选中的最后一个单元格
*  req 当为true的时候 不发送send请求
*/
U.MD.O.E.RC.removeLine = function (startCell, endCell, req) {
    var _excel = U.MD.O.E,
        _cellList = U.UF.C.toArray($(".U_MD_O_E_cell")),         //所有的单元格
        _rBList = $(".U_MD_O_E_row"),                            //所有的行板
        _rBBox = $(".U_MD_O_E_rowBoard")[0],                     //行板的父元素
        _rBLen = _rBList.length,                                 //所有的行板的长度
        _startNum = +(startCell.row),                            //获取第一个单元格的所在行数
        _endNum = +(endCell.row),                                //获取最后一个单元格的所在行数
        _rmNum = _endNum - _startNum + 1,                        //所删除行的个数
        _iRowCell,                                               //第i行的所有单元格
        _rBEl,                                                   //行板元素
        _newRowNum,                                              //未被删除的行板文本
        _mergeCellList,                                          //获取当前单元格以下的所有合并的单元格
        _colName,                                                //单元格的属性名
        _mergeId,                                                //用于判断是否是合并单元格
        s_mergerow,                                              //合并单元格的值
        e_mergerow,
        s_mergecol,                                              //删除合并单元格的值
        e_mergecol,
        _mergeArr = [],                                          //声明数组
        _mergeChangeArr = [],
        _mergeInfo,                                              //后面加入参数用于调用数组
        _mergeNum,                                               //被删除的单元格的个数
        _top,                                                    //上边距
        i;                                                      //声明变量用于for循环
    for (i = _startNum; i <= _endNum; i++) {             /*此处为 删除 对应的行板 和 对应的所有单元格*/
        _rBList[i - 1].remove();                         //删除该行对应的行板
        _iRowCell = _cellList.filter(function (el) {     //获取该行的所有单元格
            return +(el.row) === i;
        })
        _iRowCell.forEach(function (el) {                         //for循环遍历改行的所有单元格
            if (el.s_merge && (_mergeId !== el.s_merge)) {        //如果是合并单元格的元素
                _mergeId = el.s_merge;                            //赋值
                s_mergerow = el.s_mergerow;
                e_mergerow = el.e_mergerow;
                s_mergecol = el.s_mergecol;
                e_mergecol = el.e_mergecol;                       //给单元格赋值拆分合并
                if (_startNum <= s_mergerow && _endNum >= e_mergerow) {  //选择区域大于单元格区域时 非截取合并单元格情况
                    el.remove();                                        //删除单元格
                    return;                                             返回
                }

                //这三种情况表示则 截取合并单元格删除的情况
                if ((_startNum <= s_mergerow && _endNum >= s_mergerow)) {      //截取上半部分的情况
                    _mergeNum = _endNum - s_mergerow + 1    //从头开始 被删除的单元格个数
                    s_mergerow = s_mergerow + _mergeNum - _rmNum;       //重新设置合并单元格的开头
                    e_mergerow = e_mergerow - _rmNum;       //重新设置合并单元格的结尾
                    _mergeInfo = {                          //声明数组
                        smergeId: "POS_" + s_mergecol + "_" + s_mergerow,
                        emergeId: "POS_" + e_mergecol + "_" + e_mergerow,
                        row: s_mergerow,
                        col: s_mergecol,
                        endRow: e_mergerow,
                        endCol: e_mergecol
                    };
                    _mergeArr.push(_mergeInfo);             //调用函数
                } else if (_startNum <= e_mergerow && _endNum >= e_mergerow) {    //截取下半部分的情况
                    _mergeNum = e_mergerow - _startNum + 1;    //从尾开始 被删除的单元格个数
                    e_mergerow = e_mergerow - _mergeNum; //重新设置合并单元格的结尾
                    _mergeInfo = {                       //声明数组
                        smergeId: "POS_" + s_mergecol + "_" + s_mergerow,   //赋值给id
                        emergeId: "POS_" + e_mergecol + "_" + e_mergerow,
                        row: s_mergerow,
                        col: s_mergecol,
                        endRow: e_mergerow,
                        endCol: e_mergecol
                    };
                    _mergeArr.push(_mergeInfo);
                } else if (_startNum > s_mergerow && _endNum < e_mergerow) {    //截取中间部分的情况
                    e_mergerow = e_mergerow - _rmNum; //重新设置合并单元格的结尾
                    _mergeInfo = {
                        smergeId: "POS_" + s_mergecol + "_" + s_mergerow,
                        emergeId: "POS_" + e_mergecol + "_" + e_mergerow,
                        row: s_mergerow,
                        col: s_mergecol,
                        endRow: e_mergerow,
                        endCol: e_mergecol
                    };
                    _mergeArr.push(_mergeInfo);
                }
                var _splitCells = $("#" + _mergeId)[0];   //声明变量选择指定的对象
                _excel.RC.splitCells(_splitCells, true);  //拆分单元格     
            }
            el.remove();
        });
    }
    for (i = _endNum + 1; i <= _rBLen; i++) {       /* 此处为移动删除行下的 所有单元格 */
        _rBEl = _rBList[i - 1];                    //行板元素
        _newRowNum = +(_rBEl.innerText) - _rmNum;  //这里处理参数
        _rBEl.firstChild.textContent = _newRowNum;
        $(_rBEl).eAttr("rowname", _newRowNum);
        _iRowCell = _cellList.filter(function (el) {    //获取该行的所有单元格
            return +(el.row) === i;
        })
        _top = _rBEl.offsetTop;                     //赋以上边距
        _iRowCell.forEach(function (el) {           //遍历获取的所有单元格
            el.style.top = _top + "px";             //给予上边距的值
            $(el).eAttr("row", _newRowNum);         //返回值
            _colName = el.col;
            el.id = "POS_" + _colName + "_" + _newRowNum;
        });
    }

    _mergeCellList = _cellList.filter(function (el) {   //获取当前单元格以下的所有合并的单元格 
        return +(el.s_mergerow) > _startNum;
    });

    _mergeCellList.forEach(function (el) {      /*此处为 修改该行下的 所有合并 单元格的 信息*/
        $(el).eAttr("s_mergerow", el.s_mergerow - _rmNum);
        $(el).eAttr("e_mergerow", el.e_mergerow - _rmNum);
        $(el).eAttr("s_merge", "POS_" + el.s_mergecol + "_" + el.s_mergerow);
        $(el).eAttr("e_merge", "POS_" + el.e_mergecol + "_" + el.e_mergerow);
    });

    console.log(_mergeArr);
    var smergeCell,
        emergeCell;                             //声明变量
    _mergeArr.forEach(function (json) {
        smergeCell = $("#" + json.smergeId)[0]; //需要合并的开始单元格
        emergeCell = $("#" + json.emergeId)[0]; //需要合并的结束单元格
        _excel.RC.mergeCells(smergeCell, emergeCell, true);
        json.content = smergeCell.innerHTML;
    });


    var _data = {
        start: _startNum,    //第几行开始
        end: _endNum,         //第几行结束
        lineNum: _rmNum,        //删除的行数
        mergeArr: _mergeArr
    };

    U.MD.O.E.dataChange(U.MD.O.E.excelInfo("delLine", _data), req);
};

/**
*  添加列功能
*  checkdCell 被选中的最后一个单元格
*  colNums 列数
*  req 当为true的时候 不发送send请求
*/
U.MD.O.E.RC.addCol = function (checkdCell, colNums, req) {
    var _excel = U.MD.O.E,
        _cellBox = $(".U_MD_O_E_cellBox")[0],                   //单元格的最大的包
        _cellList = U.UF.C.toArray($(".U_MD_O_E_cell")),        //所有的单元格
        _rBList = $(".U_MD_O_E_row"),                           //所有的行板
        _cBList = $(".U_MD_O_E_column"),                        //所有的列板
        _cBBox = $(".U_MD_O_E_colBoard")[0],                    //所有的列版的包
        _cellLast = checkdCell,                                 //被选中单元格中的最后一个
        _colNum = _cellLast.col,                                //获取最后一个单元格的所在列数
        _cBoardCurrent = $(".U_MD_O_E_column")[_colNum - 1],    //获取除了最后一个列版的所以列版
        _cBoardNext,                                            //当前单元格下一列所对应的列板
        _colNext,                                               //单元格的下一列的所有元素
        _cBLen = _cBList.length,                                //所有列板的长度
        _width,                                                 //当前单元格的下一列的宽
        _left,                                                  //当前单元格的下一列的左边距
        _frag = $$("frag"),                                     //声明节点DocumentFragment是一种“轻量级”的文档，可以包含和控制节点，但不会像完整的文档那样占用额外的资源。
        _newEl,                                                 //合并单元格中 最大的元素 的列
        _addWidth,                                              //新增的单元格的宽度
        _iColCell,                                              //第i列的所有单元格
        _mergeChangeArr = [],                                   //声明数组后面用于调用函数
        _rowName,                                               //单元格列的属性名
        _mergeCellList,                                         //当前选中单元格的行
        _mergeId,                                               //当前选中单元格的id
        _newCol,                                                //添加列的位置
        _newcB,                                                 //新的列板
        _colRule,                                               //获取的行尺
        _colName,                                               //克隆的列
        i,                                                      //声明变量后面用于for循环
        j;
    if (_colNum < _cBLen) {                             //如果选中的行不是最后一行 
        _cBoardNext = $(".U_MD_O_E_column")[_colNum];   //当前单元格下一列所对应的列板
        _colNext = _cellList.filter(function (el) {     //当前单元格的下一列的所有元素
            return +(el.col) === (_colNum + 1);         //返回值
        });
        _width = _cBoardNext.offsetWidth;               //给当前单元格下一列所对应的列板赋值宽
        _left = _cBoardNext.offsetLeft;                 //给当前单元格下一列所对应的列板赋值左边距
    } else {
        _cBoardNext = _cBoardCurrent                    //给当前单元格下一列所对应的列板
        _colNext = _cellList.filter(function (el) {     //当前单元格的下一列的所有元素
            return +(el.col) === (_colNum);             //返回值
        });
        _width = _cBoardCurrent.offsetWidth;            //给当前单元格下一列的所有元素赋值宽
        _left = _cBoardCurrent.offsetLeft;              //给当前单元格下一列的所有元素赋值左边距
    }   

    _addWidth = _width * colNums,                       //声明宽度
    _cBBox.style.width = _cBBox.offsetWidth + _addWidth + "px"; //所有的列版的包赋值宽度
    _colNext.forEach(function (el) {                    //for循环遍历
        _rowName = +(el.row);       
        _colName = +(el.col);
        var colLen;
        if (_colNum < _cBLen) {                         //如果选中的行不是最后一行 
            i = 0;
            colLen = colNums;                           //colNums为添加列的 数量 这里是循环添加 colNums 列
        } else {
            i = 1;
            colLen = colNums + 1;                       //此处为选中最后一列 时的处理
        }
        var _newEl = el.cloneNode(),
            _mergeArr,
            _mergeEl;
        if (el.s_mergecol === _colName) {         //如果克隆的列 与 合并单元格中 最大的元素 的列 相同
            _mergeId = el.s_merge;                //最大单元格的id 
            _newEl.style.display = "block";       //为显示
            _newEl.style.width = _width + "px";   //为宽度
            _newEl.style.height = _rBList[_rowName - 1].offsetHeight + "px";    //为高度
            $(_newEl).eRmAttr("s_mergecol");
            $(_newEl).eRmAttr("s_mergerow");
            $(_newEl).eRmAttr("e_mergecol");
            $(_newEl).eRmAttr("e_mergerow");
            $(_newEl).eRmAttr("s_merge");
            $(_newEl).eRmAttr("e_merge");          //返回各种参数
        }
        if (el.s_merge && el.s_merge !== _mergeId) {                 /*(合并单元格 中间 点击添加列的情况:    此处为将选中的列的 右边的合并列一律修改信息)
                                                                     克隆的元素是被合并的单元格 且 不是最大合并单元格 所在的列*/
            _mergeId = el.s_merge;                                  //最大单元格的id 
            _mergeEl = $("#" + _mergeId)[0];                        //选择指定的对象
            _mergeEl.style.width = _mergeEl.offsetWidth + _addWidth + "px";        //修改最大合并 单元格的宽度
            _mergeArr = _cellList.filter(function (el) {            //此处为将筛选 选中的列的 右边的合并列一律修改信息)
                return el.s_merge === _mergeId;                     //返回值
            })
            _mergeArr.forEach(function (el) {                       //for循环遍历选中的列的
                $(el).eAttr("e_mergecol", el.e_mergecol + colNums);
                $(el).eAttr("e_merge", "POS_" + el.e_mergecol + "_" + el.e_mergerow);
            });

            var temp = {                                            //声明数组
                col: el.s_mergecol,
                row: el.s_mergerow
            };
            _mergeChangeArr.push(temp);
        }
        for (; i < colLen; i++) {                                 //此处为添加新的行榜
            _newEl = _newEl.cloneNode();
            if (el.s_mergecol && el.s_mergecol !== _colName) {    //如果克隆的是非最大单元格的元素 
                $(_newEl).eAttr("s_merge", el.s_merge);
                $(_newEl).eAttr("s_mergerow", el.s_mergerow);
                $(_newEl).eAttr("s_mergecol", el.s_mergecol);
                $(_newEl).eAttr("e_mergerow", el.e_mergerow);
                $(_newEl).eAttr("e_mergecol", el.e_mergecol);
                $(_newEl).eAttr("e_merge", "POS_" + _newEl.e_mergecol + "_" + _newEl.e_mergerow);
            }
            _newEl.style.left = _left + _width * i + "px";      //赋值对象的左边距
            _newCol = _colName + i;                             //添加列的位置 为当前列的位置 + i;
            $(_newEl).eAttr("col", _newCol);
            _newEl.row = el.row;
            _newEl.id = "POS_" + _newCol + "_" + _rowName;
            U.MD.O.E.BC.Focus(_newEl);                          //添加单元格聚焦事件
            U.MD.O.E.BC.dragCheckd(_newEl);                     //添加拖拽选中事件
            _frag.appendChild(_newEl);
        }
    });

    for (i = 0; i < colNums; i++) {                              //此处为添加新的列榜
        _newcB = _cBoardNext.cloneNode(true);
        _colName = +(_cBoardCurrent.colname);                   
        _newcB.firstChild.textContent = _excel.fromCharCode(_colName + 1);
        $(_newcB).eAttr("colname", _colName + 1);
        _colRule = $(_newcB).find(".U_MD_O_E_colRule");
        U.MD.O.E.BC.colExpanding(_colRule);
        U.MD.O.E.BC.cBoardChecked(_newcB);                      //添加点击 拖拽功能
        _excel.After(_cBoardCurrent, _newcB);
        _cBoardCurrent = _newcB;
    };

    for (i = _colNum + 1; i <= _cBLen; i++) {                   //此处是操作单元格的
        _cBList[i - 1].firstChild.textContent = _excel.fromCharCode(i + colNums);
        $(_cBList[i - 1]).eAttr("colname", i + colNums)
        _iColCell = _cellList.filter(function (el) {
            return (+(el.col) === i) && el.parentNode.nodeType !== 11;
        })
        _left = _cBList[i - 1].offsetLeft;
        _iColCell.forEach(function (el) {
            _frag.appendChild(el);
            el.style.left = _left + "px";
            _rowName = el.row;
            _newCol = +(i + colNums);
            el.id = "POS_" + _newCol + "_" + _rowName;
            $(el).eAttr("col", _newCol);
        })
    }

    _cellBox.appendChild(_frag);

    _mergeCellList = _cellList.filter(function (el) {   //获取当前单元格以下的所有合并的单元格
        return +(el.s_mergecol) > _colNum;
    });

    _mergeCellList.forEach(function (el) {              /*此处为 修改该行下的 所有合并 单元格的 信息*/
        $(el).eAttr("s_mergecol", el.s_mergecol + colNums);
        $(el).eAttr("e_mergecol", el.e_mergecol + colNums);
        $(el).eAttr("s_merge", "POS_" + el.s_mergecol + "_" + el.s_mergerow);
        $(el).eAttr("e_merge", "POS_" + el.e_mergecol + "_" + el.e_mergerow);
    });

    var _data = {
        start: _colNum,                                 //第几行开始添加 列
        colNums: colNums,                               //添加几列
        sizeChange: (_cBoardNext.offsetWidth === U.MD.O.E.colBoardWidth ? false : _cBoardNext.offsetWidth),       //如果高度等于单元格初始化宽度(200) 则为false  否则将宽度存起来
        mergeArr: _mergeChangeArr                       //需要修改被合并单元格的元素 的 信息
    };

    U.MD.O.E.dataChange(U.MD.O.E.excelInfo("addCol", _data), req);

}

/**
*  删除列功能
*  startCell 选中的第一个单元格
*  endCell 选中的最后一个单元格
*  req 当为true时不发送send请求
*/
U.MD.O.E.RC.removeCol = function (startCell, endCell, req) {    //传入参数
    var _excel = U.MD.O.E,
        _cellList = U.UF.C.toArray($(".U_MD_O_E_cell")),        //所有的单元格
        _cBList = $(".U_MD_O_E_column"),                        //所有的列板
        _cBBox = $(".U_MD_O_E_colBoard")[0],                    //列板的父元素
        _cBLen = _cBList.length,                                //列板的总个数
        _startNum = +(startCell.col),                           //获取第一个单元格的所在列数
        _endNum = +(endCell.col),                               //获取最后一个单元格的所在列数
        _rmNum = _endNum - _startNum + 1,                       //所删除的列的个数
        _rmWidth = 0,                                           //所需要删除的宽度
        _cellList,                                              //该列的所有单元格
        _cBEl,                                                  //列板的元素
        _newColNum,                                             //新的元素的移动
        _iColCell,                                              //第 i 列 所有单元格
        _mergeId,                                               //获取的id
        _mergeCellList,                                         //当前的所有单元格
        _mergeArr = [],                                         //声明数组
        _rowName,
        _left,                                                  //单元格的左边距
        i;
    for (i = _startNum; i <= _endNum; i++) {             //此处为删除要删的列(单元格) 包括 对应的列板
        _rmWidth += _cBList[i - 1].offsetWidth;         //获取所需要删除的宽度
        _cBList[i - 1].remove();                        //删除该列对应的列板
        _iColCell = _cellList.filter(function (el) {    //获取该列的所有单元格
            return +(el.col) === i;                     //返回值
        });
        _iColCell.forEach(function (el) {
            if (el.s_merge && (_mergeId !== el.s_merge)) {        //如果是合并单元格的元素
                _mergeId = el.s_merge;
                s_mergerow = el.s_mergerow;
                e_mergerow = el.e_mergerow;
                s_mergecol = el.s_mergecol;
                e_mergecol = el.e_mergecol;
                if (_startNum <= s_mergecol && _endNum >= e_mergecol) {  //选择区域大于单元格区域时 非截取合并单元格情况
                    el.remove();                                         //删除单元格
                    return;
                }

                //这三种情况表示则 截取合并单元格删除的情况
                if ((_startNum <= s_mergecol && _endNum >= s_mergecol)) {        //截取左半部分的情况
                    _mergeNum = _endNum - s_mergecol + 1                         //从头开始 被删除的单元格个数        
                    s_mergecol = s_mergecol + _mergeNum - _rmNum;                //重新设置合并单元格的开头 
                    e_mergecol = e_mergecol - _rmNum;                            //重新设置合并单元格的结尾 
                    _mergeInfo = {                                               //生成数组
                        smergeId: "POS_" + s_mergecol + "_" + s_mergerow,        //定义参数
                        emergeId: "POS_" + e_mergecol + "_" + e_mergerow,
                        row: s_mergerow,
                        col: s_mergecol,
                        endRow: e_mergerow,
                        endCol: e_mergecol
                    };
                    _mergeArr.push(_mergeInfo);
                    console.log(1);
                } else if (_startNum <= e_mergecol && _endNum >= e_mergecol) {    //截取下半部分的情况
                    _mergeNum = e_mergecol - _startNum + 1;                       //从尾开始 被删除的单元格个数
                    e_mergecol = e_mergecol - _mergeNum;                         //重新设置合并单元格的结尾
                    _mergeInfo = {
                        smergeId: "POS_" + s_mergecol + "_" + s_mergerow,
                        emergeId: "POS_" + e_mergecol + "_" + e_mergerow,
                        row: s_mergerow,
                        col: s_mergecol,
                        endRow: e_mergerow,
                        endCol: e_mergecol
                    };
                    _mergeArr.push(_mergeInfo);
                    console.log(2);
                } else if (_startNum > s_mergecol && _endNum < e_mergecol) {    //截取中间部分的情况
                    e_mergecol = e_mergecol - _rmNum;                           //重新设置合并单元格的结尾
                    _mergeInfo = {                                              //生成数组
                        smergeId: "POS_" + s_mergecol + "_" + s_mergerow,
                        emergeId: "POS_" + e_mergecol + "_" + e_mergerow,
                        row: s_mergerow,
                        col: s_mergecol,
                        endRow: e_mergerow,
                        endCol: e_mergecol
                    };
                    _mergeArr.push(_mergeInfo);
                    console.log(3);
                }
                var _splitCells = $("#" + _mergeId)[0];
                _excel.RC.splitCells(_splitCells, true);  //拆分单元格     
            }
            el.remove();                                 //删除不必要的参数
        });
    }
    for (i = _endNum + 1; i <= _cBLen; i++) {           //此处为 被删列后的所有元素的移动 和信息 修改
        _cBEl = _cBList[i - 1];                         //列板元素
        _newColNum = +(_cBEl.colname) - _rmNum;         
        _cBEl.firstChild.textContent = _excel.fromCharCode(_newColNum);
        $(_cBEl).eAttr("colname", _newColNum);
        _iColCell = _cellList.filter(function (el) {//获取该列的所有单元格
            return +(el.col) === i;
        });
        _left = _cBEl.offsetLeft;
        _iColCell.forEach(function (el) {               //for循环被删列后的所有元素
            el.style.left = _left + "px";               //制造左边距
            $(el).eAttr("col", _newColNum);
            _rowName = el.row;                          //调整参数
            el.id = "POS_" + _newColNum + "_" + _rowName;
        });
    }
    _cBBox.style.width = _cBBox.offsetWidth - _rmWidth + "px"; //赋值列板的父元素的宽度

    _mergeCellList = _cellList.filter(function (el) {   //获取当前单元格以下的所有合并的单元格 
        return +(el.s_mergecol) > _startNum;
    });

    _mergeCellList.forEach(function (el) {      /*此处为 修改该列下的 所有合并 单元格的 信息*/
        $(el).eAttr("s_mergecol", el.s_mergecol - _rmNum);
        $(el).eAttr("e_mergecol", el.e_mergecol - _rmNum);
        $(el).eAttr("s_merge", "POS_" + el.s_mergecol + "_" + el.s_mergerow);
        $(el).eAttr("e_merge", "POS_" + el.e_mergecol + "_" + el.e_mergerow);
    });


    var smergeCell,                         //生成遍历
        emergeCell;
    _mergeArr.forEach(function (json) {     //for循环遍历json数组
        smergeCell = $("#" + json.smergeId)[0];
        emergeCell = $("#" + json.emergeId)[0];//赋值json数组的参数
        _excel.RC.mergeCells(smergeCell, emergeCell, true);
        json.content = smergeCell.innerHTML;
    })

    var _data = {
        start: _startNum,        //第几列开始,
        end: _endNum,           //第几列结束
        colNums: _rmNum,        //删除的列数
        mergeArr: _mergeArr
    };

    U.MD.O.E.dataChange(U.MD.O.E.excelInfo("delCol", _data), req);

}

/**
*  拆分单元格功能
*  cell 需要拆分的单元格
*  dataChange 如果存在 则不修改data的后台数据
*  req 当为true时不发送send请求
*/
U.MD.O.E.RC.splitCells = function (cell, dataChange, req) {
    if (!(cell.s_merge)) return;
    var _excel = U.MD.O.E,                                      
        _cellList = U.UF.C.toArray($(".U_MD_O_E_cell")),        //所有的单元格
        _startX = +(cell.col),                                  //单元格 列
        _startY = +(cell.row),                                  //单元格 行
        _endX = +(cell.e_mergecol),                             //获取最后一个单元格的所在列数
        _endY = +(cell.e_mergerow),                             //获取最后一个单元格的所在行数
        _width = $(".U_MD_O_E_column")[_startX - 1].offsetWidth,//单元格列的宽度
        _height = $(".U_MD_O_E_row")[_startY - 1].offsetHeight, //单元格行的高度
        _id,
        _cell,
        i,
        j;
    cell.edited = true;
    for (i = _startX; i <= _endX; i++) {        /*此处是 将被隐藏的单元格 display改为block*/
        for (j = _startY; j <= _endY; j++) {    //for循环嵌套获取所有的单元格
            _id = "POS_" + i + "_" + j;
            _cell = $("#" + _id)[0];
            _cell.style.display = "block";
            $(_cell).eRmAttr("s_mergecol");
            $(_cell).eRmAttr("s_mergerow");
            $(_cell).eRmAttr("e_mergecol");
            $(_cell).eRmAttr("e_mergerow");
            $(_cell).eRmAttr("s_merge");
            $(_cell).eRmAttr("e_merge");
        }
    }
    cell.style.width = _width + "px";       //给所有单元格赋值宽度
    cell.style.height = _height + "px";     //给所有单元格赋值高度

    if (dataChange) return;
    var _data = {                           //生成数组
        col: _startX,
        row: _startY
    };

    U.MD.O.E.dataChange(U.MD.O.E.excelInfo("splitCells", _data), req);    //合并时 保存数据
};

/**
*  合并单元格功能
*  startCell 选中的第一个单元格
*  endCell 选中的最后一个单元格
*  dataChange 如果存在 则不修改data的后台数据
*  req 如果存在 则不发送send请求
*/
U.MD.O.E.RC.mergeCells = function (startCell, endCell, dataChange, req) {
    var _excel = U.MD.O.E;
    if (!startCell || !endCell || endCell === startCell) return;
    var _startCell = startCell,             //选中的第一个单元格
        _startcol = _startCell.col,         //开始x坐标
        _startrow = +(_startCell.row),      //开始y坐标
        _endCell = endCell,                 //选中的最后一个单元格
        _endcol = +(_endCell.col),          //结束x坐标
        _endrow = +(_endCell.row),          //结束y坐标
        _mergeWidth = 0,                            //合并后的总宽度
        _mergeHeight = 0,                           //合并后的总高度
        _crossCol = _endcol - _startcol + 1,        //所跨越的列
        _crossRow = _endrow - _startrow + 1,        //所跨越的行
        _cellList = U.UF.C.toArray($(".U_MD_O_E_cell")),        //所有的单元格
        _checkCellList,
        _cBList = $(".U_MD_O_E_column"),            //所有的列板
        _rBList = $(".U_MD_O_E_row"),               //所有的行板
        _cell,
        i,
        _cellcol,                                   //第 i 列 所有单元格
        _cellrow,                                   //第 i 行 所有单元格
        len = _cellList.length;
    _startCell.edited = true;
    for (i = _startcol; i <= _endcol; i++) {         //此处计算合并后单元格的宽
        _mergeWidth += _cBList[i - 1].offsetWidth;
    }

    for (i = _startrow; i <= _endrow; i++) {         //此处计算合并后单元格的高
        _mergeHeight += _rBList[i - 1].offsetHeight;
    }
    _checkCellList = _cellList.filter(function (el) {        //此处相当于 获取 被选中元素 (这里不用class获取是因为 要考虑 互联)
        _cellcol = +(el.col);
        _cellrow = +(el.row);
        return (_cellcol >= _startcol && _cellcol <= _endcol) && (_cellrow >= _startrow && _cellrow <= _endrow);
    })
    if (_startCell.s_merge) return;
    _checkCellList.forEach(function (el) { //for循环遍历获取每一个选中的元素（单元格）
        el.style.display = "none";          //让他隐藏
        $(el).eAttr("s_merge", "POS_" + _startcol + "_" + _startrow);
        $(el).eAttr("e_merge", "POS_" + _endcol + "_" + _endrow);
        $(el).eAttr("s_mergeCol", _startcol);
        $(el).eAttr("e_mergeCol", _endcol);
        $(el).eAttr("s_mergeRow", _startrow);
        $(el).eAttr("e_mergeRow", _endrow);//返回值
        if (_startCell.innerText) return;  //判断文本内容后返回值
        _startCell.innerText = el.innerText;
    })

    _startCell.style.width = _mergeWidth + "px"; //赋值选中的第一个单元格的宽度
    _startCell.style.height = _mergeHeight + "px"; //赋值选中的第一个单元格的高度
    _startCell.style.display = "block";         //赋值选中的第一个单元格的显示
    if (dataChange) return;
    var _data = {                               //生成数组
        row: _startrow,
        col: _startcol,
        content: startCell.innerHTML,
        cssText: startCell.style.cssText,
        endRow: _endrow,
        endCol: _endcol
    };

    U.MD.O.E.dataChange(U.MD.O.E.excelInfo("merge", _data), req);    //合并时 保存数据
};

/*
* 任务栏重命名
* task 选中的工作表
*/
U.MD.O.E.RC.taskRename = function (task) {
    var _task = task,                       //获取任务栏
    _text = task.firstChild.textContent,    //获取任务栏的名字
    _input;
                                             //    _name = _task.innerHTML;
    $(_task).addClass('U_MD_O_E_task_renameing'); //修改该工作表的定位模式
    $$('input',
        { 'type': 'text', 'id': 'rename', 'value': _text,
            'style': { 'cssText': 'width:109px;height:38px;position: absolute;left:0;top:0;text-align: center;font-size: 16px;line-height:38px;' }
        },                                   //在任务栏生成按钮，赋样式属性
    _task);
    _input = $('#rename')[0];                //获取input
    _input.focus()                          //获取焦点//获取光标
    _input.onblur = function (e) {
        U.UF.EV.stopBubble(e);              //阻止冒泡        
        _task.innerHTML = _input.value;
        $(_task).removeClass('U_MD_O_E_task_renameing'); //完成修改后移除input
        var _data = {                       //声明数组
            name: _input.value,
            id: _task.id
        }
        U.MD.O.E.dataChange(U.MD.O.E.excelInfo("reNameTask", _data));//修改时 保存数据
    }
    $(_input).bind('keypress', function (e) {
        U.UF.EV.stopBubble(e); //阻止冒泡        
    });
    $(_input).bind('keydown', function (e) {
        U.UF.EV.stopBubble(e); //阻止冒泡        
    });
    $(_input).bind('keyup', function (e) {
        U.UF.EV.stopBubble(e); //阻止冒泡        
    });
    $(_input).bind('dblclick', function (e) {
        U.UF.EV.stopBubble(e); //阻止冒泡        
    })
}

/*
* 任务栏删除
* req如果存在 则不像后台发送请求
*/
U.MD.O.E.RC.taskDelete = function (task, req) {
    var _task = task,           //获取任务栏
        _id = _task.id,         //声明ID
        _switchTask,
        _data = {               //声明数组
            id: _id
        };

    if ($(".U_MD_O_E_task ").length === 3) {//只有一个工作表是不能删除
        U.Alert("至少要有一个工作表！");    //弹窗
    } else if (_id === U.MD.O.E.taskId) {   //如果要删除的工作表等于当前选中工作表
        _switchTask = _task.nextElementSibling || _task.previousElementSibling;   //获取下一个工作表元素 如果不存在 则切换为上一个工作表元素
        $(_switchTask).addClass("U_MD_O_E_taskCheck");
        U.MD.O.E.taskId = _switchTask.id;   //重新赋值ID
        U.MD.O.E.rePrintExcel();            //重新打印工作表        

        U.MD.O.E.dataChange(U.MD.O.E.excelInfo("deleteTask", _data), req); //删除时保存数据，req如果存在 则不像后台发送请求
        _task.remove();
    } else {
        U.MD.O.E.dataChange(U.MD.O.E.excelInfo("deleteTask", _data), req); //删除时保存数据，req如果存在 则不像后台发送请求
        _task.remove();
    }
}

/*
* 任务栏复制
* task 选中的工作表
*/
U.MD.O.E.RC.taskCopy = function (task) {
    var _task = task;              //获取任务栏
    U.MD.O.E.taskCopyId = _task.id;//赋值id
    U.MD.O.E.addTask();             //复制任务栏
}

/*
* 单元格复制 
*/
U.MD.O.E.RC.cellCopy = function () {
    var _focusBox = $("#U_MD_O_E_focusBox")[0],                
        _editorBox = $("#U_MD_O_E_editorBox")[0],               
        _cellList = U.UF.C.toArray($(".U_MD_O_E_cellCheckd"));  //获取单元格
    if (!_cellList.length) return;
    U.MD.O.E.RC.cellTaste.copyContent = _cellList;              //复制单元格
    return true;
}
/*
* 单元格粘贴
*/
U.MD.O.E.RC.cellTaste = function (_arrjson, _arrcontent) {
    var _copycontent = U.MD.O.E.RC.cellTaste.copyContent, //复制选中的单元格
         _cutcontent = U.MD.O.E.RC.cellTaste.cutContent, //剪切选中的单元格
        _leftCorner = U.UF.C.toArray($(".U_MD_O_E_cellCheckd"))[0]; //粘贴选中的左上角单元格
    if (_cutcontent) {                                          //如果是剪切有内容
        var _cutCellColfirst = _cutcontent[0].col,              //要剪切的选中的第一个单元格的列
            _cutCellRowfirst = _cutcontent[0].row;              //要剪切的选中的第一个单元格的行
        _filterCutContent = _cutcontent.filter(function (e) {   //过滤给隐藏的div
            return e.style.display != "none";                   //返回值过滤给隐藏的div
        });
        for (var i = 0; i < _filterCutContent.length; i++) {                                //for循环遍历过滤给隐藏的div
            _cute_col = _filterCutContent[i].e_mergecol - _filterCutContent[i].s_mergecol, //合并单元格col头和尾的差值
                _cute_row = _filterCutContent[i].e_mergerow - _filterCutContent[i].s_mergerow; //合并单元格row头和尾的差值
            _cutCellCol = _filterCutContent[i].col;                                            //指定单元格的行板
            _cutCellRow = _filterCutContent[i].row;                                            //指定单元格的列板
            _cutCellColDifference = _cutCellCol - _cutCellColfirst;
            _cutCellRowDifference = _cutCellRow - _cutCellRowfirst;
            _leftCol = _leftCorner.col;
            _leftRow = _leftCorner.row;
            _cutColDifference = _leftCol + _cutCellColDifference;                               //相差的列数
            _cutRowDifference = _leftRow + _cutCellRowDifference;                               //相差的行数
            if (_cute_col) {                                                                    //调用合并单元格的接口
                U.MD.O.E.RC.mergeCells($("#POS_" + _cutColDifference + "_" + _cutRowDifference)[0], $("#POS_" + (_cutColDifference + _cute_col) + "_" + (_cutRowDifference + _cute_row))[0]);
            }
            _cutNewCell = $("#POS_" + _cutColDifference + "_" + _cutRowDifference)[0];
            _cutNewCell.innerHTML = _filterCutContent[i].innerHTML;
            _filterCutContent[i].innerHTML = "";
            U.MD.O.E.RC.cellTaste._filterCutContent = null;
        }

    } else if (_copycontent) {                   //如果是粘贴有内容
        var _cellColfirst = _copycontent[0].col, //要复制的选中的第一个单元格的列
            _cellRowfirst = _copycontent[0].row, //要复制的选中的第一个单元格的行
            _copydata = [];
        _filterCopyContent = _copycontent.filter(function (e) {//过滤给隐藏的div
            return e.style.display != "none";
        });
        for (var i = 0; i < _filterCopyContent.length; i++) {
            _cellCol = _filterCopyContent[i].col;
            _cellRow = _filterCopyContent[i].row;
            _cellColDifference = _cellCol - _cellColfirst;
            _cellRowDifference = _cellRow - _cellRowfirst;
            _leftCol = _leftCorner.col;
            _leftRow = _leftCorner.row;
            _colDifference = _leftCol + _cellColDifference; //相差的列数
            _rowDifference = _leftRow + _cellRowDifference; //相差的行数

            _e_col = _filterCopyContent[i].e_mergecol - _filterCopyContent[i].s_mergecol, //合并单元格col头和尾的差值
            _e_row = _filterCopyContent[i].e_mergerow - _filterCopyContent[i].s_mergerow; //合并单元格row头和尾的差值
            if (_e_col) {//调用合并单元格的接口
                U.MD.O.E.RC.mergeCells($("#POS_" + _colDifference + "_" + _rowDifference)[0], $("#POS_" + (_colDifference + _e_col) + "_" + (_rowDifference + _e_row))[0]);
            }
            _newCell = $("#POS_" + _colDifference + "_" + _rowDifference)[0];
            _newCell.innerHTML = _filterCopyContent[i].innerHTML;

            var _data = {
                row: _newCell.row,
                col: _newCell.col,
                content: _newCell.innerHTML,
                innerText: _newCell.innerText           //之所以要发innerText 是因为要用来判断data数据里单元格的内容如果被改为空 则删除掉该单元格的数据 
            };                                          //讲内容打包给后台
            _copydata.push(_data);
        }
        U.MD.O.E.dataChange(U.MD.O.E.excelInfo("blur", _copydata));
    } else if (_arrjson) {
        var _cellColDifference = 0;
        var _cellRowDifference = 0;
        var _copydata = [];
        for (var i = 0; i < _arrjson.td; i++) {
            _leftCol = _leftCorner.col;
            _leftRow = _leftCorner.row;
            _maxcol = _leftCol + (_arrjson.age - 1);
            _maxrow = _leftRow + (_arrjson.tr - 1);
            if ((_leftCol + _cellColDifference) > _maxcol) {
                _cellColDifference = 0;
                _cellRowDifference += 1;
            }
            _newCell = $("#POS_" + (_leftCol + _cellColDifference) + "_" + (_leftRow + _cellRowDifference))[0];
            _cellColDifference += 1;
            _newCell.innerHTML = _arrcontent[i];
            var _data = {
                row: _newCell.row,
                col: _newCell.col,
                content: _newCell.innerHTML,
                innerText: _newCell.innerText  //之所以要发innerText 是因为要用来判断data数据里单元格的内容如果被改为空 则删除掉该单元格的数据 
            };  //讲内容打包给后台
            _copydata.push(_data);
        }
    }
    U.MD.O.E.dataChange(U.MD.O.E.excelInfo("blur", _copydata));
}
/*
* 单元格剪切
*/
U.MD.O.E.RC.cellCut = function () { 
    var _focusBox = $("#U_MD_O_E_focusBox")[0],
        _editorBox = $("#U_MD_O_E_editorBox")[0],
        _cellList = U.UF.C.toArray($(".U_MD_O_E_cellCheckd")); //选中的div
    if (!_cellList.length) return;
    U.MD.O.E.RC.cellTaste.cutContent = _cellList;
}

/*
* 删除A链接
*/
U.MD.O.E.RC.clearAContent = function () {
    var _editorBox = $("#U_MD_O_E_editorBox")[0],       //选择A连接的包
        _cellList = U.UF.C.toArray($(".U_MD_O_E_cellCheckd"));
    _a = $('a', _editorBox.focusEl)[0];                 //获取选区中的第一个a标签
    $$("div", {}, _cellList[0]);                        //创建一个div
    _cellList[0].children[1].innerText = _a.innerText; //赋值给创建的div
    _cellList[0].removeChild(_a);                       //删除第一个a标签
    var _data = {                                       //生成数组
        row: _cellList[0].row,
        col: _cellList[0].col,
        content: _cellList[0].innerHTML
    }
    U.MD.O.E.dataChange(U.MD.O.E.excelInfo("clearAContent", _data));//删除时 保存数据
};

/*
* 插入链接
* cell 单元格
*/
U.MD.O.E.RC.insertLink = function (cell) {
    U.UF.E.excelAddHref();
}
/*-------------------------------------------------------------------------- 以下右键待开发--------------------------------------------------------------------------*/
/*
* 插入图片
* cell 单元格
*/
U.MD.O.E.RC.insertImg = function (cell) {
    U.Alert("暂未开发!");
}

/*
* 清除样式
* cellList 单元格集合
*/
U.MD.O.E.RC.clearStyle = function (cellList) {
    var _eiditorBox = $("#U_MD_O_E_editorBox")[0],  //获取单元格的父元素
        _cellCheckd = $(".U_MD_O_E_cellCheckd");    //获取单元格
    for (var i = 0; i < _cellCheckd.length; i++) {  //for循环遍历单元格
        _cellCheckd[i].style.fontWeight = "";
        _cellCheckd[i].style.fontStyle = "";
        _cellCheckd[i].style.textDecoration = "";
        _cellCheckd[i].style.textAlign = "";
        _cellCheckd[i].style.verticalAlign = "";
        _cellCheckd[i].style.display = "";          //单元格清除样式
        if (_cellCheckd[i].children[0])             //这边判断为第一个子元素
            _cellCheckd[i].children[0].style.verticalAlign = "";
        _cellCheckd[i].style.color = "";
        _cellCheckd[i].style.backgroundColor = "";
        _cellCheckd[i].style.fontFamily = "";
        _cellCheckd[i].style.fontSize = "";         //清除第一个子元素的样式
    }
    _eiditorBox.style.fontWeight = "";
    _eiditorBox.style.fontStyle = "";
    _eiditorBox.style.textDecoration = "";
    _eiditorBox.style.textAlign = "";
    _eiditorBox.style.verticalAlign = "";
    _eiditorBox.style.color = "";
    _eiditorBox.style.fontFamily = "";
    _eiditorBox.style.fontSize = "";                //清除单元格父元素的样式
}

/*
* 清除内容
* cellList 单元格集合
*/
U.MD.O.E.RC.clearContent = function (cellList) {
    var _cellList = U.UF.C.toArray($(".U_MD_O_E_cellCheckd")), //选中的div
        _dataArr = [];                                          //声明一个数组
    for (var i = 0; i < _cellList.length; i++) {                //for循环遍历选中的单元格
        if (_cellList[i].innerText) {                           //判断选中单元格的内容
            _cellList[i].innerText = "";                        //清除内容
            var _data = {
                row: _cellList[i].row,
                col: _cellList[i].col,
                content: _cellList[i].innerHTML,
                innerText: _cellList[i].innerText              //之所以要发innerText 是因为要用来判断data数据里单元格的内容如果被改为空 则删除掉该单元格的数据 
            };                                                 //将内容打包给后台
            _dataArr.push(_data);
        }

    }
    U.MD.O.E.dataChange(U.MD.O.E.excelInfo("blur", _dataArr));    //聚焦时 保存数据
}

/*
* 设置列宽
* startCol 开始列
* endCol 结束列
* colWidth 列宽
*/
U.MD.O.E.RC.cBoardsetWidth = function (startCol, endCol, colWidth) {
    var _cBoardList = U.UF.C.toArray($(".U_MD_O_E_column")),    //声明变量为表格列
        _setcBArr = _cBoardList.filter(function (el) {
            return el.colname >= startCol && el.colname <= endCol && el.offsetWidth !== (+colWidth);
        }),                                                     //创建一个包含新数组,测试开始列到结束列的列宽，通过时放入数组
        _dataArr = [],
        _colBoard = $(".U_MD_O_E_colBoard")[0];
        _setcBArr.forEach(function (el) {                       //for循环遍历列板
        _moveDis = colWidth - el.offsetWidth;
        var data = {                                            //声明数组
            initWidth: el.offsetWidth,
            colName: el.colname,
            moveDis: _moveDis
        }
        el.style.width = colWidth + "px";
        _colBoard.style.width = _colBoard.offsetWidth + _moveDis + "px"; //设置列宽
        _dataArr.push(data);
    });
    U.MD.O.E.BC.colExpandingEnd(_dataArr);
}

/*
* 隐藏列
* startCol 开始列
* endCol 结束列
*/
U.MD.O.E.RC.cBoardHide = function (startCol, endCol) {
    U.Alert("暂未开发!");
}

/*
* 取消隐藏列
* startCol 开始列
* endCol 结束列
*/
U.MD.O.E.RC.cBoardCancelHide = function (startCol, endCol) {
    U.Alert("暂未开发!");
}

/*
* 设置行高
* startRow 开始行
* endRow 结束行
* rowHeight 行高
*/
U.MD.O.E.RC.rBoardsetHeight = function (startRow, endRow, rowHeight) {
    var _rBoardList = U.UF.C.toArray($(".U_MD_O_E_row")), //声明变量为表格列
        _setrBArr = _rBoardList.filter(function (el) {
            return el.rowname >= startRow && el.rowname <= endRow && el.offsetHeight !== (+rowHeight);
        }),                                                 //创建一个包含新数组,测试开始列到结束列的列宽，通过时放入数组
        _dataArr = [],
        _rowBoard = $(".U_MD_O_E_rowBoard")[0];
    _setrBArr.forEach(function (el) {
        _moveDis = rowHeight - el.offsetHeight;
        var data = {//声明数组
            initHeight: el.offsetHeight,
            rowName: el.rowname,
            moveDis: _moveDis
        }
        el.style.height = rowHeight + "px";
        _rowBoard.style.height = _rowBoard.offsetHeight + _moveDis + "px"; //设置列宽
        _dataArr.push(data);
    });
    U.MD.O.E.BC.rowExpandingEnd(_dataArr);
}

/*
* 隐藏行
* startRow 开始行
* endRow 结束行
*/
U.MD.O.E.RC.rBoardHide = function (startRow, endRow) {
    U.Alert("暂未开发!");
}

/*
* 隐藏行
* startRow 开始行
* endRow 结束行
*/
U.MD.O.E.RC.rBoardCancelHide = function (startRow, endRow) {
    U.Alert("暂未开发!");
}