CocoRoboDesktop/js/UOffice/Word/U.Word.js

//查看指定文件,,判断是否保存或者覆盖，包括创建邀请协作人员，创建编辑历史，创建生成链接.创建热门模板。加载当前word文档的内容。创建光标，监控键盘输入等。这里是iframe中的word起始点。
//监控输入输出，
//添加成员，共同编辑。

Namespace.register("U.Word");
//由于当前文档的js是加载在ifame里面的，获取不到外部的文档(www.1473.cn)信息。所以通过传递参数设置全局变量的形式保存当前文档信息。
//id是word文档id，PID是文档归属的目录id，fileinfo是文档的实体信息fileinfo，OL初始化回调函数，userid是当前文档创建者的id。 historyid就是最新历史记录的id
U.Word.TF = { "ID": null, "PID": "", "fileinfo": "", "userid": "", historyid: US.NU };
US = parent.US;

//#region 初始化区域


//链接形式点击查看Word资料，例1：  /usercontrols/Word.htm?ID=a0373130-be97-db03-4e74-9967c1038d13
//例2：a0373130-be97-db03-4e74-9967c1038d13.1473.cn
//例3：短域名   example.1473.cn
window.onload = function () {
    U.D.TopForm();            //让弹框置顶。 
    U.M.ShieldedRightAndSelect();      //屏蔽右键菜单等功能按键判断
    var _fileid = U.M.QueryString("ID"); //获取登录着id
    if (_fileid) {
        parent.U.A.Request(US.Auth, ["GetFileContent", _fileid], U.Word.AsynGOF, [[$("body")[0], true]]);
    };
}

//获取文件异步

U.Word.AsynGOF = function (r, UDOD) {
    var _result = r.value.UsOffice || ""; //或者的作用是：右键新建word，没有保存时给""。
    //设置内容为空。
    //$("body").addAttrArray({ "style": {}, "innerHTML": "" });
    U.M.loadHtml(document.body, _result);
    return true;
}

//------------------------------------------------------------------------------初始化Word----------------------------------------------------------------------------
//查看指定文件,,判断是否保存或者覆盖，包括创建邀请协作人员，创建编辑历史，创建生成链接.创建热门模板。加载当前word文档的内容。创建光标，监控键盘输入等。这里是iframe中的word起始点。

//fileinfo ? fileinfo.UserDirectoryID : ""  如果有文件id则表示文件已经在数据库存在，如果没有id，表示是新word。
//fileinfo 文件信息
//fileinfo ? fileinfo.UserId : userInfo.userid  如果有文件信息，则所有者为该文件的创建者，否则为自己的用户id。
U.Word.Load = function (fileid, fileinfo, uid, iframe) {    //UDID  这个文件的id   UDE  这个文件的基本信息    userid  这个文件创始人的id  UAE  object返回值 
    //U.Word.Tool(fileinfo); //创建邀请协作人员，创建编辑历史，创建生成链接.创建热门模板的窗体，同时创建了编辑区域 
    U.Word.Variable(fileid, fileinfo, uid, iframe); //初始化全局变量
    U.Word.Panel.Loadeditor(fileinfo); //加载word的编辑器
    U.Word.Panel.LoadPlayUser(fileinfo); //加载协助人员窗体
    U.Word.Panel.Loadlink(fileinfo); //加载链接窗体
    U.Word.Panel.LoadHotTemplates(); //加载热门模板
    U.Word.Panel.LoadOfficeHistory(fileinfo); //加载历史记录
    U.Word.LoadContent(fileid, fileinfo); //初始化内容 只有加载出word内容的情况下触发
    U.Word.timelyUpdate(); //实时更新历史记录以及文档
}

/**
* 加载Word编辑区域的内容
*
*/
U.Word.LoadContent = function (fileid, fileinfo) {
    //如果有文件内容，则hascontent为true.
    var hascontent; //bool型变量
    if (fileinfo) {
        hascontent = U.Ut.isString(fileinfo.UsOffice);
    }
    //如果没有加载到，则去数据库加载
    if (fileid && !hascontent) { //获取查看的office内容
        parent.U.A.Request(US.Auth, ["GetFileContent", fileid], U.Word.AsynLoad, ["", fileid, fileinfo]); //获取office内容
        return;
    }

    //创建光标，监控键盘输入(包含粘贴板,回车，删除，分页等系统操作),等。
    U.Word.OLWord(fileinfo); //word加载处理
}

//异步获取Word编辑区域的数据
U.Word.AsynLoad = function (r) {     //object 值
    var context = r.context,     //获取array值
        _fileid = context[1],         //获取文件id
        _fileinfo = context[2],        //获取文件信息
        _uid = context[3],           //用户id
        r = r.value;   //服务器返回的值。
    _fileinfo.UsOffice = r.UsOffice || "";  //word内容
    U.Word.LoadContent(_fileid, _fileinfo); //查看文件
}

/**
* 初始化全局变量
*
*/
U.Word.Variable = function (fileid, fileinfo, uid, iframe) {

    //由于iframe和www.1473.cn不能相互调用文档信息，所以通过这个形式添加文档的ID和当前创建文档用户的id以及当前文档的信息保存到全局变量中
    var _UTE = U.Word.TF;
    _UTE.ID = fileid; //文档id
    _UTE.userid = uid; //创建用户id
    _UTE.fileinfo = fileinfo;  //文件信息实体 fileinfo
    _UTE.UDED = iframe; //在www.1473.cn的域层的iframe
}

//#region

/**
* 初始化Word，//创建光标，监控键盘输入(包含粘贴板,回车，删除，分页等系统操作),等。
*
* @param  {object}  文档信息 或 null 

*/
U.Word.OLWord = function (fileinfo) {
    var i,
       _content, //word文件内容保存在这里
       _cursor; //光标

    //得到可编辑区域变量
    var _child = $("#UD_SYQXR").Child();
    var _editarea = $(_child[_child.length - 1]).Child()[1]; //可编辑区域，是_content的父亲

    //廖泽愈写的，要放到其他位置。视图生成
    //    U.Word.ViewDisplayon(); //视图关闭
    //    U.Word.ViewDisplayc(); //



    //新建文件没有文件内容，所以需要判断，以后可以再考虑。
    if (!fileinfo) {
        _content = _editarea.innerHTML;
    }
    else {
        _content = fileinfo["UsOffice"];
    }

    //    U.Word.AsynGetTemp(_content); //异步加载模板原型

    //默认设置可编辑为true
    $(_editarea).addAttrArray({
        "innerHTML": "",
        "contentEditable": "true"
    });
    //得到整理好的内容，以便插入光标在末尾
    _content = U.Word.lastContent(_editarea, _content);

    //创建光标的地方
    //同时也是出了键盘事件的地方，U.Word.Keyboard是键盘事件，作为回调函数传递给光标进行处理。
    ////把键盘事件和光标一起绑定，因为要使用光标的地方全部都要监控键盘输入输出，所以绑定在一起，如果有机会，可以独立。
    //监控键盘输入(包含粘贴板,回车，删除，分页等系统操作),等。
    _cursor = U.OU.WordFocus(_editarea, _content, U.Word.Keyboard); //编辑绑定

    //???????????前面是聚焦还是已经插入光标
    //找到子元素，实质是向子元素追加光标
    _editarea = $(_editarea).Child();
    //插入光标到指定位置。
    _cursor.QX(1, 1, _editarea[_editarea.length - 1]);
    //保存光标变量。
    _cursor.CreateR();
}


//得到整理好的内容，以便插入光标在末尾
U.Word.lastContent = function (_editarea, content) {
    var _tmp;
    var _content = content;
    //如果word有内容，则自动排版分页，目的是得到内容，正常显示，以便创建光标时正常写入，把光标放入最末尾。
    if (_content) {//内容插入
        _tmp = $($$("div", { "innerHTML": _content })).Child();
        for (i = 0; i < _tmp.length; i++) {
            if (_tmp[i].className == "U_Boom_CO_Editor_body_main_m") {
                _content = "";
                if (!i) {
                    _editarea.innerHTML = $(_tmp[i]).Child()[1].innerHTML;
                }
                else {
                    //这部分处理的是当word编辑器没有内容时的分页，从数据库加载大数据内容时还不能实现，使用U.Word.PageData做分页处理。
                    U.Word.Page($(_editarea).Parent(), null, $(_tmp[i]).Child()[1].innerHTML); //生成下一页
                }
            }
        }
    }
    else {  //空文字处理
        _content = "<div><br /></div>"; //追加光标其实是追加到div之间。
    }
    return _content;
}


//#endregion    

//#region 保存区域

//关闭保存文件
U.Word.CSave = function (cb) {
    if (U.Word.BCWJ()) { //关闭同时保存文件
        parent.U.UI.Confirm("是否保存文件", [U.Word.Save, [cb]], UFN);
    }
    else { //直接退出
        U.M.apply(this, [cb])();
    }
}

//保存Word
U.Word.Save = function (cb) {
    //判断用户是否登录，只有登录用户才能保存信息
    if (!top.U.U.L.isLogin()) {
        //获取编辑区域的元素
        var _diskdiv, //disk的窗体
        _isdisplay, //云盘是否已经隐藏
        _isopen, //是否已经打开
        _isftp, //判断用户是否为ftp用户
        _isgroupuser; //判断用户是否在群里操作群文件
        var _wordinfo = U.Word.TF; //word全局变量 包含了uw文件的文件信息 等
        var _fileinfo = _wordinfo["fileinfo"]; //uw文件的文件信息
        var _uid = _wordinfo.userid;
        var _iframe = _wordinfo.UDED;
        var _worddiv = $(_iframe).Parent({ usform: "true" });
        //获取编辑区域的内容
        var _editor = $("#UD_SYQXR")[0];
        var _html = _editor.innerHTML.escapeQuotes(); //获取编辑区域的html 这里保存的值包含了分页
        if (_uid == _wordinfo["userid"] || (_fileinfo && _fileinfo.GroupID == _uid)) {
            _isftp = true;
        }
        if (_fileinfo) {
            _isgroupuser = _$(US.Friend[3]).Select({ "GroupManageID": _fileinfo.UserDirectoryEncrypt, "UserId": US.userInfo.userid })[0];
        }
        var _userdisk = top.U.Dk.DiskOperatingSwitch(US.userInfo.userid); //获取用户个人网盘的信息 _userdisk.pdiv 是用户的网盘窗体

        if (_fileinfo && (_isftp || _isgroupuser)) { //判断文件是否是自己或者是ftp的文件或者是群文件
            top.U.Dk.LE.USOS(_fileinfo, _html, null, cb); //保存到数据库 
            U.Word.Panel.InsertOfficeHistory(_fileinfo.UserDirectoryID, US.userInfo.userid, _html);  //插入历史记录
        }
        //    else if (fileinfo && (!fileinfo.JD && U.Word.GCoEd(fileinfo, U.M.apply(this, [[U.Word.Save, [cb]]])))) { //这里会有一种情况就是用户群没有加载成功，去数据库中获取判断用户是否在群里
        //        U.Alert("权限初始化"); 
        //    }
        else { //文件不存在 或者文件不属于自己就创建一个新文件保存
            _isdisplay = !_userdisk.pdiv || $(_userdisk.pdiv).Parent({ usform: "true" }).style.display == "none"; //判断当前网盘是否是打开状态
            _diskdiv = top.U.D.DT.YYDK("Disk", { "userid": _uid, "directoryid": _userdisk ? _userdisk[1][1] : US.DG }); //获取弹出的网盘窗体

            //新建保存函数
            top.U.Dk.RE.CMB("uw", U.M.apply(this, [
                [top.U.Dk.LE.NUSOS, [_html, "uw", _wordinfo]], //新建成功后保存uw文件的信息
                [U.Word.YBKWJ, [U.M.apply(this, [[U.Word.BCAWJMXG, [_worddiv]]])]], //新建文件成功后修改word编辑弹出和全局变量信息
               _isdisplay ? [U.D.CloseWindow, [_diskdiv]] : [U.D.SetDTop, [_worddiv]], //保存文件需要通过云盘去操作，如果云盘在打开的状态下就不隐藏云盘如果是隐藏的状态下就隐藏云盘
                cb //回调函数chuli8
            ]), _diskdiv, _uid);
        }
    }
}


U.Word.BCAWJMXG = function (editordiv, fileinfo) {
    editordiv.id = "UD_Word" + fileinfo.UserDirectoryID; //设置元素id 为UD_SYQA + 文件id
    $("input", editordiv)[0].value = fileinfo.UserallDirectoryName; //修改文件名
}

/**
* 保存文件信息判断文档保存的状态值
*
* @param  {object}  点击的按钮元素 
* @return  {number}  保存信息的值
0 无需保存可以直接关闭
1  新建文件的保存提示
3  打开文档未编辑的保存
*/
U.Word.BCWJ = function () {
    var _wordinfo = U.Word.TF, //word对象处理
    _uid = US.userInfo.userid, //用户id
    _fileinfo = _wordinfo["fileinfo"], //文件信息
    _contentdiv = $$("div", { "innerHTML": _fileinfo.UsOffice }), //默认的文档内容
    _editor = $("#UD_SYQXR")[0]; //编辑div
    if (_fileinfo.UsOffice == null) { //新建文件没有保存的情况
        return 1;
    }
    else if (_wordinfo["ID"] && _fileinfo.UsOffice && _editor.innerHTML != _contentdiv.innerHTML) { //打开文档未编辑的保存
        return 3;
    }
    return 0; //无需保存可以直接关闭
}

//空文件保存异步
U.Word.YBKWJ = function (cb, filesinfo) {
    var _fileinfo = filesinfo[1];
    _fileinfo["UsOffice"] = $("#UD_SYQXR")[0].innerHTML;   //获取这个文件的内容
    U.Word.TF.fileinfo = _fileinfo; //设置word文件信息实体
    U.Word.TF.PID = _fileinfo.UserDirectoryParentID; //设置目录id
    U.Word.TF.ID = _fileinfo.UserDirectoryID; //设置文件的id
    U.Word.TF.userid = _fileinfo.UserId || top.US.userInfo.userid; //设置所属人信息
    if (U.Ut.isFunction(cb)) { cb(_fileinfo); } //回调函数
}

//#endregion

//#region 文件备份

/**
* 文件备份
*
* @param  {object}   文件信息
* @param  {object}   指定的Window操作层
*/
U.Word.Backup = function () {
    var _isuser, //判断是否是本人
        _isgroup; //判断是否为群

    var _wordinfo = U.Word.TF; //word全局变量 包含当前word的信息
    var _fileinfo = _wordinfo.fileinfo; //文件的信息

    if (_fileinfo) { //判断是否有文件信息

        _isuser = _fileinfo.UserId == US.userInfo.userid; //判断是否是本人
        _isgroup = _fileinfo.UserDirectoryEncrypt && _$(US.Friend[3]).Select({ "GroupManageID": _fileinfo.UserDirectoryEncrypt, "UserId": US.userInfo.userid })[0]; //判断是否为群成员备份

        if (_isuser || _isgroup) { //判断备份的文件是否为用户自己的文件

            U.Dk.DiskOperatingSwitch(US.userInfo.userid); //操作用户切换会当前登录用户

            //弹出查看备份选择
            U.Dk.VW.CCWPXZK(UDE.UserDirectoryParentID, {
                De: U.Word.BackupDe, //删除备份操作
                onclick: U.M.apply(null, [ //
                    [U.Word.OpenBF, [UW]]
                ]),
                Bo: {
                    ok: U.M.apply(null, [
                        [U.Word.OBackup, [UDE]]
                    ])
                }
            }, "Other", UDE.UserDirectoryID, U.Dk.VW.APWPTP); //弹出网盘选择框
        }
        else {
            U.Alert("无法备份他人文件");
        }
    }
    else { //没有的话保存该文件
        U.Word.WBH("", "Save", true);
    } //为存储的文件设定为存储模式
}

/**
* 备份删除
*
* @param  {object}   文件信息
* @param  {object}   当前备份文件的元素
*/
U.Word.BackupDe = function (backupdiv, fileinfo) {
    U.UI.Confirm("是否删除该备份", [U.M.apply(null, [[U.Word.NBackupDe, [fileinfo, backupdiv]]])]); //创建提示框  提示是否删除备份
}

/**
* 确定删除该备份
*
* @param  {object}   当前备份文件的元素
* @param  {object}   文件信息
*/
U.Word.NBackupDe = function (backupdiv, fileinfo) {
    // U.A.Request(US.CD, [US.DB, "UseStudio_Disk", "UD_D_DeleteBackupFile", UDE.UserDirectoryID], U.Word.AsynBackupDe, [null, backupdiv, fileinfo]); //向后台发送删除备份请求   参数为文件id  
}

/**
* 备份已经删除
*
* @param  {object}   返回值及回调传参
*/
//U.Word.AsynBackupDe = function (r) {
//    var context = r.context, //获取回调传参
//        _backupdiv = context[1], //当前备份文件的元素
//        _backuppdiv = $(_backupdiv).Parent(); //获取放置备份文件的父亲层
//    r = r.value; //函数返回值
//    U.Alert("备份删除成功"); //提示删除成功
//    $(_backupdiv).remove(); //删除当前备份文件的元素
//    if (!$(_backuppdiv).Child().length) { //如果没有备份
//        $$("div", {
//            "className": "UD_SYSXZLRSITT",
//            "innerHTML": "该目录暂无指定的内容"
//        }, _UDPD); //创建无备份提示
//    }
//}

/**
* 文件备份确定
*
* @param  {object}  创建office的容器元素 
* @param  {string}   用户id
*/
U.Word.OBackup = function (fileinfo, dirid) {
    U.A.Request(US.CD, [US.DB, "UseStudio_Disk", "AddBackupFile", fileinfo.UserDirectoryID], U.Word.AsynOBackup, [null, fileinfo, dirid]);
}

/**
* 文件备份异步
*
* @param  {object}   返回值及回调传参
*/
U.Word.AsynOBackup = function (r) {
    r = r.value; //返回值
    var context = r.context; //回调传参
    if (r) {//判断是否备份成功
        U.Alert("备份成功");
    }
}

/**
* 备份查看
*
* @param  {object}   文件信息
* @param  {object}   指定的Window操作层
*/
U.Word.OpenBF = function (fileinfo) {
    U.UI.Confirm("是否选中该备份", [U.Word.OpenNBF, [fileinfo]]);
}

/**
* 确定获取模板
*
* @param  {object}   指定的Window操作层
* @param  {object}   文件信息
*/
U.Word.OpenNBF = function (fileinfo) {
    U.Alert("文件正在加载中"); //提示加载
    U.A.Request(US.Auth, ["GetFileContent", fileinfo.UserDirectoryID], U.Word.AsynOpenBF, ["", fileinfo]); //发送获取备份请求
}

/**
* 异步加载
*
* @param  {object}   返回值及回调传参
*/
U.Word.AsynOpenBF = function (r) {
    var _editor = $("#UD_SYQXR")[0], //设置变量
        context = r.context, //获取回调传参
        _fileinfo = context[1]; //文件信息
    _fileinfo.UsOffice = r.value; //设置内容
    U.Word.OLWord(_fileinfo);
}

//#endregion

//#region 表格插入

/**
* 插入表格
*
* @param  {element} 换页元素
*/
U.Word.InsertTable = function () {
    var _UDTD, _UDSD, _UDKD, _UDMB
    _UDOD = $$("div", { "class": "U_Boom_CO_Popup_16" });
    _UDMB = $$("div", { "class": "U_Boom_CO_Popup_16_main" }, _UDOD);
    for (var i = 0; i < 7; i++) {
        for (var j = 0; j < 8; j++) {
            var a = $$("div", { "class": "U_Boom_CO_Popup_16_block", "style": { "top": i * 25 + 'px', "left": j * 26 + 'px'} }, _UDMB);
            a.x = j;
            a.y = i;
            a.onmouseover = function () {
                U.Word.SelectTable(this.x, this.y)
            }
            a.onmousedown = function () {
                U.Word.AsynInsertTable(this.x + 1, this.y + 1)
            }
        }
    }
    $$("div", { "innerHTML": "直接插入", "style": { "position": "absolute", "top": "180px"} }, _UDMB).onclick = function () {
        $(".U_Boom_CO_Popup_16_main")[0].style.display = 'none';
        $(".U_Boom_CO_Popup_16_main")[1].style.display = 'block';
    };
    _UDMB = $$("div", { "class": "U_Boom_CO_Popup_16_main", "style": { "display": "none"} }, _UDOD);
    $$("div", { "class": "U_Boom_CO_Popup_16_title", "innerHTML": "表格尺寸" }, _UDMB);
    _UDTD = $$("div", { "class": "U_Boom_CO_Popup_16_OneLine" }, _UDMB);
    _UDKD = $$("div", { "class": "U_Boom_CO_Popup_16_OneLine" }, _UDMB);
    $$("span", { "innerHTML": "列数:" }, _UDTD);
    var _h = $$("input", { "id": "U_w_table_line" }, _UDTD);
    $$("span", { "innerHTML": "行数:" }, _UDKD);
    var _l = $$("input", { "id": "U_w_table_column" }, _UDKD);
    $$("div", { "innerHTML": "表格宽度", "class": "U_Boom_CO_Popup_16_title" }, _UDMB);
    _UDTD = $$("div", { "class": "U_Boom_CO_Popup_16_OneLine" }, _UDMB);
    _UDSD = $$("span", { "innerHTML": "宽度" }, _UDTD);
    $$("span", { "innerHTML": "mm", "style": { "float": "right", "text-indent": "5px"} }, _UDTD);
    $$("input", { "id": "U_w_table_width", "value": "1", "style": { "width": "50px"} }, _UDTD);
    U.UI.Confirm("插入表格", { "width": "230px", "height": "auto" }, null, [U.Word.AsynInsertTable, [_h, _l]], _UDOD);
}

/*表格选择插入样式*/
U.Word.SelectTable = function (x, y) {
    var xx = (x % 7) + 1;
    var yy = (y % 9) + 1;
    var a = $(".U_Boom_CO_Popup_16_block");
    for (var i = 0; i < a.length; i++) {
        a[i].style.borderColor = '#9e9e9e';
    }
    for (var i = 0; i < yy; i++) {
        for (var j = 0; j < xx; j++) {
            a[j + 8 * i].style.borderColor = '#38f';
        }
    }
}
/**
* 插入表格
*
* @param  {element} 换页元素
*/
U.Word.KeyFlage = null;
U.Word.MouseMenu = $("#UD_SYQER")[0];
U.Word.AsynInsertTable = function (x, y, node) {
    var container;
    if (!x && !y) {
        U.Alert('请输入数据')
    } else {
        if (typeof x == 'object' || typeof y == 'object') {
            x = x.value;
            y = y.value;
        }
    }
    if (!node) {
        node = $(".U_Boom_CO_Editor_body_main_text")[0]
        container = $$("table", { "border": "0", "class": "U_Boom_Table", "cellpadding": "0", "cellspacing": "0" }, node);
    } else {
        container = node;
    }
    container = $$("tbody", {}, container);
    container.onkeydown = function (e) {
        if (e.ctrlKey) {
            U.Word.KeyFlage = true;
        }
    };
    container.onkeyup = function () {
        U.Word.KeyFlage = null;
    };
    for (var i = 0; i < y; i++) {
        var a = $$("tr", { "class": "U_Boom_Table_Line" }, container);
        for (var j = 0; j < x; j++) {
            var b = $$("td", { "class": "U_Boom_Table_Column" }, a);
            b.onmousedown = function (e) {
                if (e.button == 2) {
                    U.M.RLocate(U.Word.MouseMenu);
                } else {
                    U.Word.MouseMenu.removeAttribute('style');
                }
                U.Word.EditTable(this, e);
            };
            b.h = j;
            b.l = i;
        }
    }
    if ($("#U_COF")[0]) {
        $("#U_COF")[0].style.display = 'none';
    }
};
/**
* 调整拖拽表格
*
* @param  {element} 换页元素
*/
U.Word.ResizeTable = function (control, e) {
    e.stopPropagation();
    e.preventDefault();
    var startX, container = control.parentNode;
    var ThisTable = container.parentNode.parentNode.parentNode, count,
            offsetX = container.offsetLeft - ThisTable.getBoundingClientRect().left;
    offsetY = container.offsetHeight - ThisTable.getBoundingClientRect().top;
    startX = e.pageX - ThisTable.getBoundingClientRect().left;
    document.onmousemove = function (e) {
        var ThisLine = container.parentNode;
        var TabelLine = ThisTable.getElementsByClassName("U_Boom_Table_Content");
        var TablePreparColumn = [],
                TableElseColumn = [];
        for (var i = 0; i < ThisLine.childNodes.length; i++) {
            if (ThisLine.childNodes[i] == container) {
                count = i;
            }
        }
        for (var i = 0; i < TabelLine.length; i++) {
            for (var k = 0; k < TabelLine[i].childNodes.length; k++) {
                if (k == count) {
                    TablePreparColumn.push(TabelLine[i].childNodes[k]);
                }
                if (k > count) {
                    TableElseColumn.push(TabelLine[i].childNodes[k]);
                }
            }
        }
        var endX = e.pageX - ThisTable.getBoundingClientRect().left - offsetX;
        var cutX = (endX - startX) / (TableElseColumn.length / TabelLine.length);
        for (var j = 0; j < TablePreparColumn.length; j++) {
            TablePreparColumn[j].style.width = endX + 'px';
        }
        for (var l = 0; l < TableElseColumn.length; l++) {
            if (cutX > 0) {
                TableElseColumn[l].style.width = TableElseColumn[l].offsetWidth - cutX + 'px';
            } else {
                TableElseColumn[l].style.width = TableElseColumn[l].offsetWidth + Math.abs(cutX) + 'px';
            }
            TableElseColumn[l].style.background = "yellow";
        }
        startX = e.pageX - ThisTable.getBoundingClientRect().left;
        TablePreparColumn = [];
        TableElseColumn = [];
    };
    document.onmouseup = function () {
        document.onmousemove = null;
        document.onmouseup = null;
    }
};
/**
* 编辑表格
*
* @param  {element} 换页元素
*/
U.Word.EditTable = function (this_column, e) {
    //    e.stopPropagation();
    //    var Editors = $(".U_Boom_CO_Editor_body_main_text"); //编辑器
    //    var Column = $(".U_Boom_Table_Column");
    //    if (U.Word.KeyFlage) {
    //        this_column.state = true;
    //        this_column.setAttribute("contenteditable", true);
    //        this_column.style.border = "1px solid #38f";
    //    } else {
    //        for (var i = 0; i < Column.length; i++) {
    //            Column[i].state = false;
    //            Column[i].onkeydown = null;
    //            Column[i].setAttribute("contenteditable", false);
    //            Column[i].style.border = "1px solid #ccc";
    //        }
    //    }
    //    this_column.state = true;
    //    this_column.setAttribute("contenteditable", true);
    //    this_column.style.border = "1px solid #38f";
    //    this_column.onblur = function () {
    //        console.log("asdasdas")
    //    }
    //    for (var j = 0; j < Editors.length; j++) {
    //        Editors[j].setAttribute("contenteditable", false);
    //        Editors[j].onmousedown = function () {
    //            this.setAttribute("contenteditable", true);
    //            Array.prototype.forEach.call(this.getElementsByTagName('*'), function (elm) {
    //                elm.setAttribute("contenteditable", false);
    //            });
    //        }
    //    }
};
/**
* 合并、拆分单元格
*
* @param  {element} 换页元素
*/
U.Word.ColumnControl = function (fx) {
    var column = $(".U_Boom_Table_Column");
    var selectColumn = [];
    var OperateColumn = [];
    for (var i = 0; i < column.length; i++) {
        if (column[i].state) {
            selectColumn.push(column[i])
        }
    }
    if (fx == 'split') {
        if (selectColumn.length > 1) {
            U.Alert('请选择一个单元格');
            //删除每一个单元格的样式。建议改成循环
            for (var i = 0; i < elm.length; i++) {
                elm[i].removeAttribute('style');
            }
        } else {
            var _UDMB = $$("div", { "class": "U_Boom_CO_Popup_16", "style": { "height": "110px"} });
            var UDHD = $$("div", { "class": "U_Boom_CO_Popup_16_main" }, _UDMB);
            $$("div", { "class": "U_Boom_CO_Popup_16_title", "innerHTML": "拆分大小" }, UDHD);
            var _UDTD = $$("div", { "class": "U_Boom_CO_Popup_16_OneLine" }, _UDMB);
            var _UDKD = $$("div", { "class": "U_Boom_CO_Popup_16_OneLine" }, _UDMB);
            $$("span", { "innerHTML": "列数:" }, _UDTD);
            var _l = $$("input", { "id": "U_w_table_line", "value": "2" }, _UDTD);
            $$("span", { "innerHTML": "行数:" }, _UDKD);
            var _h = $$("input", { "id": "U_w_table_column", "value": "2" }, _UDKD);
            var _CUM = new U.UI.Confirm("拆分单元格", { "width": "350px", "text-align": "center" }, null, U.M.apply(null, [[U.Word.AsynInsertTable, [_h, _l, selectColumn[0]]]]), _UDMB); //创建对话框

        }
    } else {
        U.Alert('暂无法使用');
        U.Word.KeyFlage = null;
        U.Word.MouseMenu.removeAttribute('style');
        return false;
        /////以后删除
        var x = selectColumn[0].h, y = selectColumn[0].l;
        var width = 0, content = '';
        for (var i = 0; i < selectColumn.length; i++) {
            if (selectColumn[i].h == y) {///找出一行中被选中的
                OperateColumn.push(selectColumn[i]);
                x = selectColumn[i].l, y = selectColumn[i].h;
            }
        }
        for (var j = 1; j < OperateColumn.length; j++) {
            width = OperateColumn[j].parentNode.offsetWidth + width;
            content = OperateColumn[j].innerHTML + content;
            OperateColumn[j].parentNode.remove();
        }
        OperateColumn[0].parentNode.style.width = OperateColumn[0].offsetWidth + width + 'px';
        OperateColumn[0].innerHTML += content;
    }
    U.Word.KeyFlage = null;
    U.Word.MouseMenu.removeAttribute('style');
};

//#endregion

//#region 插入目录

/**
* 插入目录
*
* @param  {element} 换页元素
*/
U.Word.InserDirectory = function () {
    //    var i, _UDOCD, _UDOD = $$("div", { "class": "U_Boom_CO_Popup_15" });
    //    for (i = 0; i < 3; i++) {
    //        _UDOCD = $$("div", { "class": "U_Boom_CO_Popup_15_Cat" }, _UDOD);
    //        $$("div", { "class": "U_Boom_CO_Popup_15_Cat_Name", "innerHTML": "标题" + (i + 1), "style": { "margin-left": (i * 15) + "px"} }, _UDOCD);
    //        $$("div", { "class": "U_Boom_CO_Popup_15_Dash" }, _UDOCD);
    //        $$("div", { "class": "U_Boom_CO_Popup_15_Cat_Num", "innerHTML": "1" }, _UDOCD);
    //    }
    //    _UDOCD = $$("div", { "class": "U_Boom_O_Novel_Cat" }, _UDOD);
    //    U.UI.Confirm("自动生成目录", { "width": "330px", "height": "auto" }, null, [U.Word.AsynInserDirectory, [_UDOD]], _UDOD);

}

/**
* 插入目录
*
* @param  {element} 换页元素
*/
U.Word.AsynInserDirectory = function () {


}

//#endregion

//#region 纸张大小

/**
* 修改纸张大小弹出
*
*/
U.Word.PaperSize = function (UDOD) {
    var i, _UDPD,
        _ClassName = [],
        _UDTD = $("#UD_SYQXR"),
        _UDOD = $$("div", { "class": "U_Boom_CO_Popup_14" }),
        _PaperSize = [
                    { "name": "A3", "class": "U_Boom_CO_PaperA3", "size": "29.7厘米 × 42厘米" },
                    { "name": "A4", "class": "U_Boom_CO_PaperA4", "size": "21厘米 × 29.7厘米" },
                    { "name": "A5", "class": "U_Boom_CO_PaperA5", "size": "14.8厘米 × 21厘米" },
                    { "name": "Web", "class": "U_Boom_CO_PaperWeb", "size": "占满屏幕" }
                     ];

    $$("div", { "innerHTML": "选择纸张大小", "class": "U_Boom_CO_Popup_14_Title" }, _UDOD);
    for (i = 0; i < _PaperSize.length; i++) {
        _UDPD = $$("div", { "class": "U_Boom_CO_Popup_14_Main", "onclick": [[U.Word.AsynPaperSize, [_PaperSize[i]["class"]]]] }, _UDOD);
        $$("div", { "innerHTML": _PaperSize[i].name, "class": "U_Boom_CO_Popup_14_Main_Name" }, _UDPD);
        $$("div", { "innerHTML": _PaperSize[i].size }, _UDPD)
    }

    for (i = 0; i < 1; i++) {
        _ClassName.push(_UDTD[0].className);
        _UDTD = _UDTD.childg(0)[0];
    }
    top.U.UI.Confirm("纸张大小", { "width": "330px", "height": "auto" }, [U.Word.AsynPaperSize, [_UDOD]], [U.Word.CancelPaperSize, [_ClassName]], _UDOD);
}

/**
* 纸张大小恢复
*
*/
U.Word.SetPaperSize = function (ClassName) {
    var i, _UDTD = $("#UD_SYQXR");
    var _user = $("#U_Boom_CO_Editor_body_left")[0].childNodes[1]; //获取邀请协作人员窗体
    var _history = $("#U_Boom_CO_Editor_body_left")[0].childNodes[2]; //获取编辑历史窗体
    var _pay = $("#U_Boom_CO_Editor_body_left")[0].childNodes[3]; //获取生产链接窗体
    var _hot = $("#U_Boom_CO_Editor_body_left")[0].childNodes[4]; //获取热门模板窗体
    $("#UD_SYQXR")[0].style.cssText = "min-width:148mm"
    _UDTD[0].className = ClassName[0];
    _UDTD[0].children[0].children[1].className = ClassName[1];
    _UDTD[0].children[0].className = ClassName[2];
    _user.style.left = _history.style.left = _pay.style.left = _hot.style.left = _UDTD[0].clientWidth + 88 + "px";
    _UDTD = _UDTD.childg(0)[0];
}



/**
*  确定纸张大小恢复
*
*/
U.Word.AsynPaperSize = function (className) {
    U.Word.SetPaperSize["U_Boom_CO_Editor_body_main " + className, "U_Boom_CO_Editor_body_main_text " + className + "C", "U_Boom_CO_Editor_body_main_m " + className];
    $[$("#U_Boom_CO_Editor_body_left")[0], $("#U_Boom_CO_Editor_body_right")[0]].css("display", className == "U_Boom_CO_PaperWeb" ? "none" : "block");
}


//#endregion

//#region 编辑处理

/**
* 键盘输入默认处理类
*
传参规范
str 字符串类型
obj 对象类型
num 数字类型
arr 数组类型
cb 回调函数
布尔类型

*/
U.Word.Keyboard = function (UTF, UDE, UTE, UT, UWE) {

    var i, _UTH, _UWH, _UDTD, _UDAD, _UDPD, _UDND, _UDFD;
    if (UTF == "UP") {
        //        U.M.StopDefault();
        //        _UDTD = UTE.PSO;
        //        _UDAD = $(_UDTD).Child();
        //        if (_UDAD.length < 1) {
        //            UTE.Replace("<div><br /></div>");
        //            //  U.OU.WordFocus(_UDTD, "<div><br /></div>", U.Word.Keyboard); //初始化焦点使用
        //        }
    }
    else if (UTF == "Cut") { //剪切处理

    }
    else if (UTF == "Copy") {

    }
    else if (UTF == "Paste") { //粘贴处理
        //        _UTH = U.M.UrlPaste();
        //        if (_UTH != "") {
        //            U.M.StopDefault();
        //            _UDTD = $("#U_Boom_Ed")[0];
        //            _UDTD.innerHTML = _UTH;
        //        }
        //        if (UTE.CTH) {
        //            U.M.StopDefault();
        //            UTE.Replace(this.CTH);
        //        }
    }

    //这里必须是word编辑模式下处理，在互联办公啊，云企建站等等就不做任何有关的处理
    else {
        switch (UTF) {
            case "Backspace": //后退处理
                _UDTD = UTE.PSO;
                _UDAD = $(_UDTD).Child();
                if ((_UDAD.length < 1 || (_UDAD.length == 1 && _UDAD[0].innerText.replace(/\u200b/g, "").length < 2)) || UTE.GetSelectedText() == _UDTD.innerText) {
                    U.M.StopDefault();
                    this.CreateR(); //重新记录光标
                    _UDPD = UTE.Parent(null, true);
                    if (!U.Word.delPage(_UDTD, UTE)) {
                        UTE.moveRange();
                        UTE.Replace("<br />");
                        UTE.QX(1, 1, _UDPD);
                    }
                }
                break;
            case "Delete": //delte处理

                break;
            case "save": //保存处理
                U.M.StopDefault();
                U.Word.Save();
                break;
            case "replace":
                alert();
                break;
            case "copy": //复制处理

                break;
            case "paste": //粘贴处理

                break;
            case "selectAll": //全选处理


                break;
            case "redo": //前进

                break;
            case "undo": //后退

                break;
            default:
                if (!(UT[1] || UT[2]) && !(UT[0] == 8 || UT[0] == 3 || UT[0] == 46 || (UT[0] > 63231 && UT[0] < 63236) || (UT[0] > 63272 && UT[0] < 63278 && UT[0] != 63274))) { //特殊键处理 
                    this.CreateR(); //重新记录光标
                    _UDPD = $(UTE.Parent(null, true)).Parent({ "tagName": "DIV" }); //获取当前行的元素
                    _UTH = UTE.getBoundingClientRect(); //获取光标位置和大小

                    //回车、键盘向下处理
                    if ((_UDPD.offsetTop + (_UDPD.offsetHeight * 2) - UTE.PSO.offsetTop) > UTE.PSO.offsetHeight && ((UTF == "Down" || UTF == "Enter" || (UTF == "Right" && UTE.GetGBWZ() >= _UDPD.innerText.length)) || (_UTH.right - _UDPD.offsetLeft - 20 >= UTE.PSO.offsetWidth))) {
                        U.M.StopDefault();
                        U.Word.Page($(UTE.PSO).Parent());
                    }


                    else if ((_UDPD.offsetTop + (_UDPD.offsetHeight * 2) - UTE.PSO.offsetTop) > UTE.PSO.offsetHeight && UTF == "Delete") {

                    }


                    //向上向左处理
                    else if (_UDPD.offsetTop - UTE.PSO.offsetTop < 50 && (UTF == "Up" || (UTF == "Left" && _UTH.right < 70))) {
                        U.M.StopDefault();
                        U.Word.Page($(UTE.PSO).Parent(), UTF);
                    }

                    //移动到最后准备输入后，判断是否已经需要换页
                    else if ((_UTH.right - _UDPD.offsetLeft - 20) >= UTE.PSO.offsetWidth || UTF == "Enter") {
                        //                        U.M.StopDefault(); //取消浏览器默认行为

                        //                        _UDND = $(_UDPD).next(); //获取当前输入行的下级元素

                        //                        //自动添加回车符号
                        //                        UTE.Replace("<div><br /></div>", null, true);

                        //换页处理
                        U.Word.PageData(UTE.PSO, _UDPD);
                    }


                    //                    //输入的内容判断处理
                    //                    else if (_UWH["OW"] >= 780) {
                    //                        //                        _UDND = $(_UDPD).next();
                    //                        //                        _UDFD = $$("frag");


                    //                        //                        if (!_UDND) {
                    //                        //                            _UDND = $$("div");
                    //                        //                        }
                    //                        //                        for (i = _UDND.innerHTML.length; i >= 0; i++) {
                    //                        //                            _UDFD.textContent += _UDND.innerHTML.substring(_UDND.innerHTML.length - 1, _UDND.innerHTML.length);
                    //                        //                            if (_UDND.offsetWidth <= 780) {
                    //                        //                                break;
                    //                        //                            }

                    //                        //                        }

                    //                    }

                    //                    //                    _UDND = $(_UDPD).next();


                    //                    //                    for (i = 0; i < _UDAD.length; i++) {

                    //                    //                    }


                }
                break;
        }
    }

    //自动生成换行处理
    //U.Word.Wrap(UTE.PSO);
}

/**
* word保存在数据库中，内容超过一页，则使用此分页函数。
*
* @param  {element} 换页元素
*/
U.Word.PageData = function (UDPD, UDSD) {
    //变量定义
    var i, j, k, _UWH, _UDMD, _UDCD,
    _str = "", //需要换行的文字
    _ptop = UDPD.offsetTop,
    _pheight = UDPD.offsetHeight,
    _height = UDSD.offsetHeight,
    _UDAD = $(UDPD).Child();
    //循环判断元素是否超出位置
    for (i = 0; i < _UDAD.length; i++) {
        _UWH = U.M.GetElementInfo(_UDAD[i]);
        if ((_UWH["OH"] + _UWH["OT"]) - UDPD.offsetTop + _height > UDPD.offsetHeight) {
            _UDMD = U.Word.Page($(UDPD).Parent(), null, null, true); //换页到下级元素
            _UDMD.appendChild(_UDAD[i], _UDMD.firstChild); //插入到最前面



            /*
            _UDCD = $(_UDAD[i].children);
            if (_UDCD.length) { //如果有子元素处理子元素方式
            for (k = _UDCD.length - 1; k >= 0; k--) {
            if (_UDAD[i].children[k].tagName == "DIV") { //div的处理方式
            _UDMD.appendChild(_UDAD[i].children[k], _UDMD.firstChild);
            }
            else if (_UDAD[i].innerText) { //span 等处理方式



            //                        _str = $$(_UDAD[i].tagName, { className: _UDAD[i].className, "style": { "cssText": _UDAD[i].style.cssText} });

            //                        for (j = _UDAD[i].innerText.length; i >= 0; j++) {
            //                            _str.innerText += _UDAD[i].innerText.substring(j, 1)
            //                        }

            }
            else { //#text 处理方式
            _UDAD[i].textContent;
            }
            }
            }
            else { //直接处理整行
            _UDMD.appendChild(_UDAD[i], _UDMD.firstChild);
            }
            */
        }
    }


    /*
    //变量定义
    var i, j, k, _UWH, _UST, //下面使用到的变量
    _UDTD = $("#U_Boom_Ed")[0], //编辑大小使用元素
    _UDAD = $("div", UDPD); //所有的元素

    //循环查看
    for (i = 0; i < _UDAD.length; i++) {

    _UDTD.innerHTML = "";
    _UDTD = $$("span", { "innerHTML": _UDAD[i].innerHTML }, _UDTD);

    for (k = _UDAD[i].children.length - 1; (U.M.GetElementInfo(_UDAD[i]).OW >= 750 && k >= 0); k--) {

    if (_UDAD[i].children[k].innerText) {

    for (j = 0; j < _UDAD[i].children[k].innerText.length; j++) {
    _UDAD[i].children[k].innerText = "";

    }

    }
    else if (_UDAD[i].children[k].textContent) {


    }
    }
    }
    */
}

/**
* word换页
*
* @param  {element} 包含头部，尾部和编辑区域的元素
* @param  {bool} 向上或者向下翻页pagedown
* @param  {string} 是否追加元素,插入光标时还需要插入什么元素,
* @param  {bool} 换页是否不聚焦,b如果为true，则聚焦，否则，不聚焦
*/
U.Word.Page = function (currentpage, pagedown, str, b) {
    //UDOD 包含头部，尾部和编辑区域的元素和_pagediv结构上一模一样。区别在_pagediv可能是下一页，可能是上一页。
    var _pagediv; // 由于是多页，所以需要另外建立一个div，包含下面的头部，内容，底部,和currentpage结构上一样，上一页和下一页的区别。
    var _header; //头部
    var _editor; //编辑区域，没有头部和尾部,这个是返回值。
    var _cursor; //需要插入的光标。
    var _footer; //尾部

    _wordeditor = $(currentpage).Parent(); //生成新页面追加到最大编辑器，所以要找父亲元素
    //向上翻页
    if (pagedown) {
        _pagediv = $(currentpage).prev()[0]; //查找上一个元素
        if (_pagediv) {
            _editor = $(_pagediv).Child()[1]; //得到编辑元素
        }
    }
    //向下翻页
    else {
        _pagediv = $(currentpage).next()[0]; //查找下一个元素
        //如果不存在下一页，则创建新页
        if (!_pagediv) {
            //
            _pagediv = $$("div", { "className": "U_Boom_CO_Editor_body_main_m" }, _wordeditor); //由于是多页，所以需要另外建立一个div，包含下面的头部，内容，底部
            _header = $$("div", { "className": "U_Boom_CO_Editor_body_main_border" }, _pagediv); //头部信息
            $$("div", { "className": "U_Boom_CO_Editor_body_main_bordero" }, _header); //头部的左上角
            $$("div", { "className": "U_Boom_CO_Editor_body_main_bordert" }, _header); //头部的右上角
            _editor = $$("div", { "className": "U_Boom_CO_Editor_body_main_text", contentEditable: "true", spellcheck: "false", "innerHTML": "", "id": "Txt" + Guid.newGuid() }, _pagediv); //编辑器区域
            _footer = $$("div", { "className": "U_Boom_CO_Editor_body_main_border" }, _pagediv);
            $$("div", { "className": "U_Boom_CO_Editor_body_main_borders" }, _footer);
            $$("div", { "className": "U_Boom_CO_Editor_body_main_borderf" }, _footer);

            //换页是否插入光标
            if (b !== true) {
                _cursor = U.OU.WordFocus(_editor, str || "<div><br /></div>", U.Word.Keyboard); //初始化焦点使用
            }
            else { //添加不换行处理
                _editor.innerHTML = str || "<div><br /></div>";
            }
        }
        else {
            _editor = $(_pagediv).Child()[1]; //得到编辑元素
        }
    }
    if (_editor) {
        //真正的插入光标
        _editor = $(_editor).Child(); //得到"<div><br /></div>";
        var _line = pagedown ? _editor.length - 1 : 0; //向上翻聚焦到最后一行，向下翻聚焦到第一页
        _editor = _editor[_line]; //获得插入光标位置
        if (b !== true) {
            _cursor = U.OU.WordFocus(_editor, false, U.Word.Keyboard); //初始化焦点使用，只是聚焦作用，还没插入光标
            _cursor.QX(1, 1, _editor); //插入光标
        }
    }
    return _editor; //
}

/**
* 移除页面
*
* @param  {element} 换页元素
*/
U.Word.delPage = function (UDOD, UTE) {
    var _UDPD = $(UDOD).Parent();
    _UDSD = $(_UDPD).prev()[0];
    if (_UDSD) {
        $(_UDPD).remove();
        _UDMD = $(_UDSD).Child()[1];
        _UDMD = $(_UDMD).Child() || $(_UDMD);
        _UDMD = _UDMD[_UDMD.length - 1];
        _UDMD.focus();
        if (UTE != null) {
            UTE.QX(1, 1, _UDMD); //初始化焦点使用
            UTE.CreateR(false);
        }
        return true;
    }
    return false;
}


//#endregion

//#region 其他功能

document.oncontextmenu = U.M.StopDefault; //禁止右键菜单

//新建Word文件
U.Word.NWWJ = function () {
    top.U.D.DT.YYDK("Word", US.userInfo);
}

//文件下载成指定的格式
U.Word.XZZDGS = function () {
    top.U.D.Office.ZDGSXZ(U.Word.TF["ID"], "html", U.Word);
}


//获取office模板
U.Word.GetTemp = function (UTF) {
    var _UDOD = $("#UD_SYQXR")[0];
    if (!_UDOD.innerText.length || _UDOD.innerText == $$("div", { "innerHTML": "&#8203;" }).innerText) {
        U.Word.GSTemp(UTF);
    }
    else {
        //top.U.UI.Confirm("是否覆盖内容", []);
        U.Word.GSTemp(UTF);
    }
}

//加载模板
U.Word.GSTemp = function (UTF) {
    U.Alert("模板在加载中");
    var _UIS = "";
    if (UTF == "Word" || UTF == "Web") {
        _UIS = UTF; UTF = UTF == "Word" ? "US_O_Meeting" : "US_O_Website";
    }
    U.MD.IframeLoad($$("iframe", { "width": 0, "height": 0, top: true, "style": { "display": "none" }, "src": "/usercontrols/US_Office/Word_Model/html/" + UTF + ".htm?domain=" + document.domain + "&isEmpty=" + _UIS }, document.body), U.Word.AsynGetTemp);
}

//获取word
U.Word.AsynGetTemp = function (UTH) {
    var i,
        _USE,
        _UDOD = $("#UD_SYQXR")[0],
        _child = $(_UDOD).Child(),
        _editarea = $(_child[0]).Child()[1];
    UTH = U.Ut.isString(UTH) ? UTH : this.contentWindow ? this.contentWindow.document.body.innerHTML : null;
    window.isPrint = false; //回到默认模式
    U.D.Office.Editable = true;
    U.M.loadHtml(_editarea, UTH); //编辑绑定
    // U.Word.View(window.isPrint ? "Word" : "Web"); //加载模板
}

//每五秒更新历史记录以及文档内容
U.Word.timelyUpdate = function () {
    U.Word.TimeColse();
    U.Word.TimesetInterval = setInterval(function () {
        //判断文件是否存在
        var _wordinfo = U.Word.TF; //word全局变量 包含了uw文件的文件信息 等
        var _fileinfo = _wordinfo["fileinfo"]; //uw文件的文件信息
        if (_fileinfo) {
            var _fileid = _fileinfo.UserDirectoryID;
            var UDOD = $("#U_Boom_CO_Editor_body_left_invite_history")[0]; //历史记录框
            //获取历史记录更新
            U.A.Request(US.CD, [US.DB, "UseStudio_Office", "SelectOfficeHistory", _fileid, _wordinfo.historyid, 1, 10], U.Word.AsyntimelyUpdate, [null, UDOD]);
            // U.A.Request(US.CD, [US.DB, "UseStudio_Office", "SelectOfficeHistory", _fileid, "00000000-0000-0000-0000-000000000000", 1, 10]), U.Word.Panel.OnDisplayD, [null, UDOD]; //显示全部    ---耗流量- -.        
            U.MD.uploading(UDOD)//取消loading
        }
    }, 5000)
}

//每五秒更新历史记录以及文档内容异步处理
U.Word.AsyntimelyUpdate = function (r) {
    var _wordinfo = U.Word.TF; //word全局变量 包含了uw文件的文件信息 等
    var _fileinfo = _wordinfo["fileinfo"]; //uw文件的文件信息
    var _fileid = _fileinfo.UserDirectoryID;
    if (r.value.length) { //判断是否有最新的历史记录
        parent.U.A.Request(US.Auth, ["GetFileContent", _fileid], U.Word.AsynLoad, ["", _fileid, _fileinfo]); //有历史记录同时更新文本信息
        U.Word.Panel.AsynViewEditHistory(r); //打印历史记录
    }
}

U.Word.TimeColse = function () {
    clearInterval(U.Word.TimesetInterval)
}

//#endregion