web/test/oaassist/WpsOAAssist/js/common/func_tabcontrol.js

var EnumOAFlag = {
    DocFromOA: 1,
    DocFromNoOA: 0
}

//记录是否用户点击OA文件的保存按钮
var EnumDocSaveFlag = {
    OADocSave: 1,
    NoneOADocSave: 0
}

//标识文档的落地模式 本地文档落地 0 ，不落地 1
var EnumDocLandMode = {
    DLM_LocalDoc: 0,
    DLM_OnlineDoc: 1
}

//加载时会执行的方法
function OnWPSWorkTabLoad(ribbonUI) {
    wps.ribbonUI = ribbonUI;
    if (typeof(wps.Enum) == "undefined") { // 如果没有内置枚举值
        wps.Enum = WPS_Enum;
    }
    OnJSWorkInit(); //初始化文档事件(全局参数,挂载监听事件)
    // setTimeout(activeTab,2000); // 激活OA助手菜单
    OpenTimerRun(OnDocSaveByAutoTimer); //启动定时备份过程
    return true;
}

//文档各类初始化工作（WPS Js环境）
function OnJSWorkInit() {
    pInitParameters(); //OA助手环境的所有配置控制的初始化过程
    AddDocumentEvent(); //挂接文档事件处理函数
}

//初始化全局参数
function pInitParameters() {
    wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.NoneOADocSave); //初始化，没有用户点击保存按钮

    var l_wpsUserName = wps.WpsApplication().UserName;
    wps.PluginStorage.setItem(constStrEnum.WPSInitUserName, l_wpsUserName); //在OA助手加载前，先保存用户原有的WPS应用用户名称

    wps.PluginStorage.setItem(constStrEnum.OADocCanSaveAs, false); //默认OA文档不能另存为本地
    wps.PluginStorage.setItem(constStrEnum.AllowOADocReOpen, false); //设置是否允许来自OA的文件再次被打开
    wps.PluginStorage.setItem(constStrEnum.ShowOATabDocActive, false); //设置新打开文档是否默认显示OA助手菜单Tab  默认为false

    wps.PluginStorage.setItem(constStrEnum.DefaultUploadFieldName, "file"); //针对UploadFile方法设置上载字段名称

    wps.PluginStorage.setItem(constStrEnum.AutoSaveToServerTime, "10"); //自动保存回OA服务端的时间间隔。如果设置0，则关闭，最小设置3分钟
    wps.PluginStorage.setItem(constStrEnum.TempTimerID, "0"); //临时值，用于保存计时器ID的临时值

    // 以下是一些临时状态参数，用于打开文档等的状态判断
    wps.PluginStorage.setItem(constStrEnum.IsInCurrOADocOpen, false); //用于执行来自OA端的新建或打开文档时的状态
    wps.PluginStorage.setItem(constStrEnum.IsInCurrOADocSaveAs, false); //用于执行来自OA端的文档另存为本地的状态
    wps.PluginStorage.setItem(constStrEnum.RevisionEnableFlag, false) //按钮的标记控制
    wps.PluginStorage.setItem(constStrEnum.Save2OAShowConfirm, true); //弹出上传成功后的提示信息
}

//挂载WPS的文档事件
function AddDocumentEvent() {
    wps.ApiEvent.AddApiEventListener("WindowActivate", OnWindowActivate);
    wps.ApiEvent.AddApiEventListener("DocumentBeforeSave", OnDocumentBeforeSave);
    wps.ApiEvent.AddApiEventListener("DocumentBeforeClose", OnDocumentBeforeClose);
    wps.ApiEvent.AddApiEventListener("DocumentAfterClose", OnDocumentAfterClose);
    wps.ApiEvent.AddApiEventListener("DocumentBeforePrint", OnDocumentBeforePrint);
    wps.ApiEvent.AddApiEventListener("DocumentOpen", OnDocumentOpen);
    wps.ApiEvent.AddApiEventListener("DocumentNew", OnDocumentNew);
    // wps.ApiEvent.AddApiEventListener("NewDocument", OnDocumentNew);
    console.log("AddDocumentEvent");
}

/**
 * 打开插入书签页面
 */
function OnInsertBookmarkToDoc() {
    if (!wps.WpsApplication().ActiveDocument) {
        return;
    }
    OnShowDialog("selectBookmark.html", "自定义书签", 700, 440, false);
}

/**
 * 作用：打开当前文档的页面设置对话框
 */
function OnPageSetupClicked() {
    var wpsApp = wps.WpsApplication();
    var doc = wpsApp.ActiveDocument;
    if (!doc) {
        return;
    }
    wpsApp.Dialogs.Item(wps.Enum&&wps.Enum.wdDialogFilePageSetup||178).Show();
}

/**
 * 作用：打开当前文档的打印设置对话框
 */
function OnPrintDocBtnClicked() {
    var wpsApp = wps.WpsApplication();
    var doc = wpsApp.ActiveDocument;
    if (!doc) {
        return;
    }
    wpsApp.Dialogs.Item(wps.Enum&&wps.Enum.wdDialogFilePrint||88).Show();
}


/**
 * 作用：接受所有修订内容
 * 
 */
function OnAcceptAllRevisions() {
    //获取当前文档对象
    var l_Doc = wps.WpsApplication().ActiveDocument;
    if (!l_Doc) {
        return;
    }
    if (l_Doc.Revisions.Count >= 1) {
        if (!wps.confirm("目前有" + l_Doc.Revisions.Count + "个修订信息，是否全部接受？")) {
            return;
        }
        l_Doc.AcceptAllRevisions();
    }
}


/**
 * 作用：拒绝当前文档的所有修订内容
 */
function OnRejectAllRevisions() {
    var l_Doc = wps.WpsApplication().ActiveDocument;
    if (!l_Doc) {
        return;
    }
    if (l_Doc.Revisions.Count >= 1) {
        l_Doc.RejectAllRevisions();
    }
}


/**
 *  作用：把当前文档修订模式关闭
 */
function OnCloseRevisions() {
    //获取当前文档对象
    var l_Doc = wps.WpsApplication().ActiveDocument;
    OnRevisionsSwitch(l_Doc, false);
}


/**
 *  作用：把当前文档修订模式打开
 */
function OnOpenRevisions() {
    //获取当前文档对象
    var l_Doc = wps.WpsApplication().ActiveDocument;
    OnRevisionsSwitch(l_Doc, true);
}

function OnRevisionsSwitch(doc, openRevisions) {
    if (!doc) {
        return;
    }
    var l_activeWindow = doc.ActiveWindow;
    if (l_activeWindow) {
        var v = l_activeWindow.View;
        if (v) {
            //WPS 显示使用“修订”功能对文档所作的修订和批注
            v.ShowRevisionsAndComments = openRevisions;
            //WPS 显示从文本到修订和批注气球之间的连接线
            v.RevisionsBalloonShowConnectingLines = openRevisions;
        }
        if (openRevisions == true) {
            //去掉修改痕迹信息框中的接受修订和拒绝修订勾叉，使其不可用
            wps.WpsApplication().CommandBars.ExecuteMso("KsoEx_RevisionCommentModify_Disable");
        }

        //RevisionsMode:
        //wdBalloonRevisions	0	在左边距或右边距的气球中显示修订。
        //wdInLineRevisions	1	在正文中显示修订，使用删除线表示删除，使用下划线表示插入。 
        //                      这是 Word 早期版本的默认设置。
        //wdMixedRevisions	2	不支持。
        doc.TrackRevisions = openRevisions; // 开关修订
        l_activeWindow.ActivePane.View.RevisionsMode = 2; //2为不支持气球显示。

    }
}

/**
 *  作用：打开扫描仪
 */
function OnOpenScanBtnClicked() {
    var doc = wps.WpsApplication().ActiveDocument;
    if (!doc) {
        return;
    }
    //打开扫描仪
    try {
        wps.WpsApplication().WordBasic.InsertImagerScan(); //打开扫描仪
    } catch (err) {
        alert("打开扫描仪的过程遇到问题。");
    }
}

/**
 *  作用：在文档的当前光标处插入从前端传递来的图片
 *  OA参数中 picPath 是需要插入的图片路径
 *  图片插入的默认版式是在浮于文档上方
 */
function DoInsertPicToDoc() {
    console.log("DoInsertPicToDoc...");

    var l_doc; //文档对象
    l_doc = wps.WpsApplication().ActiveDocument;
    if (!l_doc) {
        return;
    }

    //获取当前文档对象对应的OA参数
    var l_picPath = GetDocParamsValue(l_doc, constStrEnum.picPath); // 获取OA参数传入的图片路径
    if (l_picPath == "") {
        // alert("未获取到系统传入的图片URL路径，不能正常插入图片");
        // return;
        //如果没有传，则默认写一个图片地址
        l_picPath="http://127.0.0.1:3888/file/OA模板公章.png"
    }

    var l_picHeight = GetDocParamsValue(l_doc, constStrEnum.picHeight); //图片高
    var l_picWidth = GetDocParamsValue(l_doc, constStrEnum.picWidth); //图片宽

    if (l_picHeight == "") { //设定图片高度
        l_picHeight = 39.117798; //13.8mm=39.117798磅
    }
    if (l_picWidth == "") { //设定图片宽度
        l_picWidth = 72; //49.7mm=140.880768磅
    }

    var l_shape = l_doc.Shapes.AddPicture(l_picPath, false, true);
    l_shape.Select();
    // l_shape.WrapFormat.Type = wps.Enum&&wps.Enum.wdWrapBehind||5; //图片的默认版式为浮于文字上方，可通过此设置图片环绕模式
}
/**
 * 作用：模拟插入签章图片
 * @param {*} doc 文档对象
 * @param {*} picPath 图片路径
 * @param {*} picWidth 图片宽度
 * @param {*} picHeight 图片高度
 */
function OnInsertPicToDoc(doc, picPath, picWidth, picHeight,callBack) {
    // alert("图片路径："+picPath);
    if (!doc) {
        return;
    }
    if (typeof picPath == "undefined" || picPath == null || picPath == "") {
        alert("未获取到系统传入的图片URL路径，不能正常插入印章");
        return;
    }
    if (!picWidth) { //设定图片宽度
        picWidth = 95; //49.7mm=140.880768磅
    }
    if (!picHeight) { //设定图片高度
        picHeight = 40; //13.8mm=39.117798磅
    }

    var selection = doc.ActiveWindow.Selection; // 活动窗口选定范围或插入点
    var pagecount = doc.BuiltInDocumentProperties.Item(wps.Enum&&wps.Enum.wdPropertyPages||14); //获取文档页数
    selection.GoTo(wps.Enum&&wps.Enum.wdGoToPage||1, wps.Enum&&wps.Enum.wdGoToPage||1, pagecount.Value); //将光标指向文档最后一页
    DownloadFile(picPath,function(url){
        selection.ParagraphFormat.LineSpacing = 12 //防止文档设置了固定行距
        var picture = selection.InlineShapes.AddPicture(url, true, true); //插入图片
        wps.FileSystem.Remove(url) //删除本地的图片
        picture.LockAspectRatio = 0; //在调整形状大小时可分别改变其高度和宽度
        picture.Height = picHeight; //设定图片高度
        picture.Width = picWidth; //设定图片宽度
        picture.LockAspectRatio = 0;
        picture.Select(); //当前图片为焦点
    
        //定义印章图片对象
        var seal_shape = picture.ConvertToShape(); //类型转换:嵌入型图片->粘贴版型图片
    
        seal_shape.RelativeHorizontalPosition = wps.Enum&&wps.Enum.wdRelativeHorizontalPositionPage||1;
        seal_shape.RelativeVerticalPosition = wps.Enum&&wps.Enum.wdRelativeVerticalPositionPage||1;
        seal_shape.Left = 315; //设置指定形状或形状范围的垂直位置（以磅为单位）。
        seal_shape.Top = 630; //指定形状或形状范围的水平位置（以磅为单位）。
        callBack&&callBack()
    })
    
}



/**
 * 作用： 把当前文档保存为其他格式的文档并上传
 * @param {*} p_FileSuffix 输出的目标格式后缀名，支持：.pdf .uof .uot .ofd
 * @param {*} pShowPrompt 是否弹出用户确认框
 */
function OnDoChangeToOtherDocFormat(p_FileSuffix, pShowPrompt) {
    var l_suffix = p_FileSuffix; // params.suffix;
    if (!l_suffix) {
        return;
    }
    //获取当前执行格式转换操作的文档
    var l_doc = wps.WpsApplication().ActiveDocument;
    if (!l_doc) {
        return;
    }
    console.log(pShowPrompt)
    if (typeof(pShowPrompt) == "undefined") {
        pShowPrompt = true; //默认设置为弹出用户确认框
    }
    //默认设置为以当前文件的显示模式输出，即当前为修订则输出带有修订痕迹的
    pDoChangeToOtherDocFormat(l_doc, l_suffix, pShowPrompt, true);
}
/**
 * 作用：获取文档的Path或者临时文件路径
 * @param {*} doc 
 */
 function getDocSavePath(doc) {
    if (!doc) {
        return;
    }
    if (doc.Path == "") { //对于不落地文档，文档路径为空
        return wps.Env.GetTempPath();
    } else {
        return doc.Path
    }
}
/**
 * 作用：把当前文档输出为另外的格式保存
 * @param {*} p_Doc 文档对象
 * @param {*} p_Suffix 另存为的目标文件格式
 * @param {*} pShowPrompt 是否弹出用户确认框
 * @param {*} p_ShowRevision :是否强制关闭修订，如果是False，则强制关闭痕迹显示。如果为true则不做控制输出。
 */
function pDoChangeToOtherDocFormat(p_Doc, p_Suffix, pShowPrompt, p_ShowRevision) {
    if (!p_Doc) {
        return;
    }

    var l_suffix = p_Suffix;
    //获取该文档对应OA参数的上载路径
    var l_uploadPath = GetDocParamsValue(p_Doc, constStrEnum.uploadAppendPath);
    if (l_uploadPath == "" || l_uploadPath == null) {
        l_uploadPath = GetDocParamsValue(p_Doc, constStrEnum.uploadPath);
    }
    var l_FieldName = GetDocParamsValue(p_Doc, constStrEnum.uploadFieldName);
    if (l_FieldName == "") {
        l_FieldName = wps.PluginStorage.getItem(constStrEnum.DefaultUploadFieldName); //默认是'file'
    }

    if (l_uploadPath == "" && pShowPrompt == true) {
        alert("系统未传入有效上载文件路径！不能继续转换操作。"); //如果OA未传入上载路径，则给予提示
        return;
    }

    if (pShowPrompt == true) {
        if (!wps.confirm("当前文档将另存一份" + l_suffix + " 格式的副本，并上传到系统后台，请确认 ？")) {
            return;
        }
    }

    // 先把文档输出保存为指定的文件格式，再上传到后台
    wps.PluginStorage.setItem(constStrEnum.OADocUserSave, true); //设置一个临时变量，用于在BeforeSave事件中判断 
    if (p_ShowRevision == false) { // 强制关闭痕迹显示
        var l_SourceName = p_Doc.Name;
        var l_NewName="";
        var docPath=getDocSavePath(p_Doc);
        if(docPath.indexOf("\\")>0){
            l_NewName = docPath + "\\B_" + p_Doc.Name;
        }else{
            l_NewName = docPath + "/B_" + p_Doc.Name;
        }
        if(docPath.indexOf("\\")>0){
            l_SourceName = docPath + "\\" + l_SourceName;
        }else{
            l_SourceName = docPath + "/" + l_SourceName;
        }

        p_Doc.SaveAs2($FileName = l_NewName, $AddToRecentFiles = false);
        p_Doc.SaveAs2($FileName = l_SourceName, $AddToRecentFiles = false);
        //以下以隐藏模式打开另一个文档
        var l_textEncoding = wps.WpsApplication().Options.DefaultTextEncoding; //默认 936
        var l_Doc = wps.WpsApplication().Documents.Open(l_NewName, false, false, false, "", "", false, "", "", 0, l_textEncoding, false);

        l_Doc.TrackRevisions = false; //关闭修订模式
        l_Doc.ShowRevisions = false; //隐含属性，隐藏修订模式
        l_Doc.AcceptAllRevisions();
        l_Doc.Save();
        handleFileAndUpload(l_suffix, l_Doc, l_uploadPath, l_FieldName);
        l_Doc.Close();
        wps.FileSystem.Remove(l_NewName); //删除临时文档
    } else {
        handleFileAndUpload(l_suffix, p_Doc, l_uploadPath, l_FieldName);
    }

    wps.PluginStorage.setItem(constStrEnum.OADocUserSave, false);

    return;
}

/**
 * 把文档转换成UOT在上传
 */
function OnDoChangeToUOF() {}

/**
 *  打开WPS云文档的入口
 */
function pDoOpenWPSCloundDoc() {
    wps.TabPages.Add("https://www.kdocs.cn");
}

/**
 *  执行另存为本地文件操作
 */
function OnBtnSaveAsLocalFile() {

    //初始化临时状态值
    wps.PluginStorage.setItem(constStrEnum.OADocUserSave, false);
    wps.PluginStorage.setItem(constStrEnum.IsInCurrOADocSaveAs, false);

    //检测是否有文档正在处理
    var l_doc = wps.WpsApplication().ActiveDocument;
    if (!l_doc) {
        alert("WPS当前没有可操作文档！");
        return;
    }

    // 设置WPS文档对话框 2 FileDialogType:=msoFileDialogSaveAs
    var l_ksoFileDialog = wps.WpsApplication().FileDialog(2);
    l_ksoFileDialog.InitialFileName = l_doc.Name; //文档名称

    if (l_ksoFileDialog.Show() == -1) { // -1 代表确认按钮
        //alert("确认");
        wps.PluginStorage.setItem(constStrEnum.OADocUserSave, true); //设置保存为临时状态，在Save事件中避免OA禁止另存为对话框
        l_ksoFileDialog.Execute(); //会触发保存文档的监听函数

        pSetNoneOADocFlag(l_doc);

        wps.ribbonUI.Invalidate(); //刷新Ribbon的状态

    };
}

//
/**
 * 作用：执行清稿按钮操作
 * 业务功能：清除所有修订痕迹和批注
 */
function OnBtnClearRevDoc() {
    var doc = wps.WpsApplication().ActiveDocument;
    if (!doc) {
        alert("尚未打开文档，请先打开文档再进行清稿操作！");
    }

    //执行清稿操作前，给用户提示
    if (!wps.confirm("清稿操作将接受所有的修订内容，关闭修订显示。请确认执行清稿操作？")) {
        return;
    }

    //接受所有修订
    if (doc.Revisions.Count >= 1) {
        doc.AcceptAllRevisions();
    }
    //去除所有批注
    if (doc.Comments.Count >= 1) {
        doc.RemoveDocumentInformation(wps.Enum&&wps.Enum.wdRDIComments||1);
    }

    //删除所有ink墨迹对象
    pDeleteAllInkObj(doc);

    doc.TrackRevisions = false; //关闭修订模式
    wps.ribbonUI.InvalidateControl("btnOpenRevision");

    return;
}

/**
 * 作用：删除当前文档的所有墨迹对象
 * @param {*} p_Doc 
 */
function pDeleteAllInkObj(p_Doc) {
    var l_Count = 0;
    var l_IsInkObjExist = true;
    while (l_IsInkObjExist == true && l_Count < 20) {
        l_IsInkObjExist = pDeleteInkObj(p_Doc);
        l_Count++;
    }
    return;
}

/**
 * 删除墨迹对象
 */
function pDeleteInkObj(p_Doc) {
    var l_IsInkObjExist = false;
    if (p_Doc) {
        for (var l_Index = 1; l_Index <= p_Doc.Shapes.Count; l_Index++) {
            var l_Item = p_Doc.Shapes.Item(l_Index);
            if (l_Item.Type == 23) {
                l_Item.Delete();
                //只要有一次找到Ink类型，就标识一下
                if (l_IsInkObjExist == false) {
                    l_IsInkObjExist = true;
                }
            }
        }
    }
    return l_IsInkObjExist;
}


/**
 * 
 */
function pSaveAnotherDoc(p_Doc) {
    if (!p_Doc) {
        return;
    }
    var l_SourceDocName = p_Doc.Name;
    var l_NewName = "BK_" + l_SourceDocName;
    p_Doc.SaveAs2(l_NewName);
    wps.WpsApplication().Documents.Open();
}


//保存到OA后台服务器
function OnBtnSaveToServer() {
    // console.log('SaveToServer');
    var l_doc = wps.WpsApplication().ActiveDocument;
    if (!l_doc) {
        alert("空文档不能保存！");
        return;
    }

    //非OA文档，不能上传到OA
    if (pCheckIfOADoc() == false) {
        alert("非系统打开的文档，不能直接上传到系统！");
        return;
    }

    //如果是OA打开的文档，并且设置了保护的文档，则不能再上传到OA服务器
    if (pISOADocReadOnly(l_doc)) {
        wps.alert("系统设置了保护的文档，不能再提交到系统后台。");
        return;
    }

    /**
     * 参数定义：OAAsist.UploadFile(name, path, url, field,  "OnSuccess", "OnFail")
     * 上传一个文件到远程服务器。
     * name：为上传后的文件名称；
     * path：是文件绝对路径；
     * url：为上传地址；
     * field：为请求中name的值；
     * 最后两个参数为回调函数名称；
     */
    var l_uploadPath = GetDocParamsValue(l_doc, constStrEnum.uploadPath); // 文件上载路径
    if (l_uploadPath == "") {
        wps.alert("系统未传入文件上载路径，不能执行上传操作！");
        return;
    }

    var l_showConfirm = wps.PluginStorage.getItem(constStrEnum.Save2OAShowConfirm)
    if (l_showConfirm) {
        if (!wps.confirm("先保存文档，并开始上传到系统后台，请确认？")) {
            return;
        }
    }

    var l_FieldName = GetDocParamsValue(l_doc, constStrEnum.uploadFieldName); //上载到后台的业务方自定义的字段名称
    if (l_FieldName == "") {
        l_FieldName = wps.PluginStorage.getItem(constStrEnum.DefaultUploadFieldName); // 默认为‘file’
    }

    var l_UploadName = GetDocParamsValue(l_doc, constStrEnum.uploadFileName); //设置OA传入的文件名称参数
    if (l_UploadName == "") {
        l_UploadName = l_doc.Name; //默认文件名称就是当前文件编辑名称
    }

    var l_DocPath = l_doc.FullName; // 文件所在路径

    if (pIsOnlineOADoc(l_doc) == false) {
        //对于本地磁盘文件上传OA，先用Save方法保存后，再上传
        //设置用户保存按钮标志，避免出现禁止OA文件保存的干扰信息
        wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.OADocSave);
        if (l_doc.Path == "") { //对于不落地文档，文档路径为空
            l_doc.SaveAs2(wps.Env.GetTempPath() + "/" + l_doc.Name, undefined, undefined, undefined, false);
        } else {
            l_doc.Save();
        }
         //执行一次保存方法
        //设置用户保存按钮标志
        wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.NoneOADocSave);
        //落地文档，调用UploadFile方法上传到OA后台
        l_DocPath = l_doc.FullName;
        try {
            //调用OA助手的上传方法
            UploadFile(l_UploadName, l_DocPath, l_uploadPath, l_FieldName, OnUploadToServerSuccess, OnUploadToServerFail);
        } catch (err) {
            alert("上传文件失败！请检查系统上传参数及网络环境！");
        }
    } else {
        // 不落地的文档，调用 Document 对象的不落地上传方法
        wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.OADocSave);
        try {
            //调用不落地上传方法
            l_doc.SaveAsUrl(l_UploadName, l_uploadPath, l_FieldName, "OnUploadToServerSuccess", "OnUploadToServerFail");
        } catch (err) {
            alert("上传文件失败！请检查系统上传参数及网络环境，重新上传。");
        }
        wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.NoneOADocSave);
    }

    //获取OA传入的 转其他格式上传属性
    var l_suffix = GetDocParamsValue(l_doc, constStrEnum.suffix);
    if (l_suffix == "") {
        console.log("上传需转换的文件后缀名错误，无法进行转换上传!");
        return;
    }

    //判断是否同时上传PDF等格式到OA后台
    var l_uploadWithAppendPath = GetDocParamsValue(l_doc, constStrEnum.uploadWithAppendPath); //标识是否同时上传suffix格式的文档
    if (l_uploadWithAppendPath == "1") {
        //调用转pdf格式函数，强制关闭转换修订痕迹，不弹出用户确认的对话框
        pDoChangeToOtherDocFormat(l_doc, l_suffix, false, false);
    }
    return;
}


/**
 * 作用：套红头
 * 所有与OA系统相关的业务功能，都放在oabuss 子目录下
 */
function OnInsertRedHeaderClick() {
    var l_Doc = wps.WpsApplication().ActiveDocument;
    if (!l_Doc) {
        return;
    }
    var l_insertFileUrl = GetDocParamsValue(l_Doc, constStrEnum.insertFileUrl); //插入文件的位置
    var l_BkFile = GetDocParamsValue(l_Doc, constStrEnum.bkInsertFile);
    if (l_BkFile == "" || l_insertFileUrl == "") {
        var height = 250;
        var width = 400;
        OnShowDialog("redhead.html", "OA助手", width, height);
        return;
    }
    InsertRedHeadDoc(l_Doc);
}


/**
 * 插入时间
 * params参数结构
 * params:{
 *   
 * }
 */
function OnInsertDateClicked() {
    var l_Doc = wps.WpsApplication().ActiveDocument;
    if (l_Doc) {
        //打开插入日期对话框
        wps.WpsApplication().Dialogs.Item(wps.Enum&&wps.Enum.wdDialogInsertDateTime||165).Show();
    }
}


/**
 * 调用文件上传到OA服务端时，
 * @param {*} resp 
 */
function OnUploadToServerSuccess(resp) {
    console.log("成功上传服务端后的回调：" + resp)
    console.log(resp)
    var l_doc = wps.WpsApplication().ActiveDocument;
    var l_showConfirm = wps.PluginStorage.getItem(constStrEnum.Save2OAShowConfirm);
    if (l_showConfirm) {
        if (wps.confirm("文件上传成功！继续编辑请确认，取消关闭文档。") == false) {
            if (l_doc) {
                console.log("OnUploadToServerSuccess: before Close");
                l_doc.Close(-1); //保存文档后关闭
                console.log("OnUploadToServerSuccess: after Close");
            }
        }
    }

    var l_NofityURL = GetDocParamsValue(l_doc, constStrEnum.notifyUrl);
    if (l_NofityURL != "") {
        l_NofityURL = l_NofityURL.replace("{?}", "2"); //约定：参数为2则文档被成功上传
        NotifyToServer(l_NofityURL);
    }
}

function OnUploadToServerFail(resp) {
    alert("文件上传失败！");
}

function OnbtnTabClick() {
    alert("OnbtnTabClick");
}



//判断当前文档是否是OA文档
function pCheckIfOADoc() {
    var doc = wps.WpsApplication().ActiveDocument;
    if (!doc)
        return false;
    return CheckIfDocIsOADoc(doc);
}

//根据传入的doc对象，判断当前文档是否是OA文档
function CheckIfDocIsOADoc(doc) {
    if (!doc) {
        return false;
    }

    var l_isOA = GetDocParamsValue(doc, constStrEnum.isOA);
    if (l_isOA == "") {
        return false
    };

    return l_isOA == EnumOAFlag.DocFromOA ? true : false;
}

//获取文件来源标识
function pGetDocSourceLabel() {
    return pCheckIfOADoc() ? "OA文件" : "非OA文件";
}



/**
 *  作用：设置用户名称标签
 */
function pSetUserNameLabelControl() {
    var l_doc = wps.WpsApplication().ActiveDocument;
    if (!l_doc) return "";

    var l_strUserName = "";
    if (pCheckIfOADoc() == true) { // OA文档，获取OA用户名
        var userName = GetDocParamsValue(l_doc, constStrEnum.userName);
        l_strUserName = userName == "" ? "未设置" : userName;
    } else {
        //非OA传来的文档，则按WPS安装后设置的用户名显示
        l_strUserName = "" + wps.PluginStorage.getItem(constStrEnum.WPSInitUserName);
    }

    return l_strUserName;
}


/**
 * 作用：判断是否是不落地文档
 * 参数：doc 文档对象
 * 返回值： 布尔值
 */
function pIsOnlineOADoc(doc) {
    var l_LandMode = GetDocParamsValue(doc, constStrEnum.OADocLandMode); //获取文档落地模式
    if (l_LandMode == "") { //用户本地打开的文档
        return false;
    }
    return l_LandMode == EnumDocLandMode.DLM_OnlineDoc;
}
/**
 *  作用：返回OA文档落地模式标签
 */
function pGetOADocLabel() {
    var l_Doc = wps.WpsApplication().ActiveDocument;
    if (!l_Doc) {
        return "";
    }

    var l_strLabel = ""; //初始化

    if (pIsOnlineOADoc(l_Doc) == true) { // 判断是否为不落地文档
        l_strLabel = "文档状态：不落地";
    } else {
        l_strLabel = l_Doc.Path != "" ? "文档状态：落地" : "文档状态：未保存";
    }

    //判断OA文档是否是受保护
    if (pISOADocReadOnly(l_Doc) == true) {
        l_strLabel = l_strLabel + "(保护)";
    }
    return l_strLabel;
}

//返回是否可以点击OA保存按钮的状态
function OnSetSaveToOAEnable() {
    return pCheckIfOADoc();
}


/**
 *  作用：根据OA传入参数，设置是否显示Ribbob按钮组
 *  参数：CtrlID 是OnGetVisible 传入的Ribbob控件的ID值
 */
function pShowRibbonGroupByOADocParam(CtrlID) {
    var l_Doc = wps.WpsApplication().ActiveDocument;
    if (!l_Doc) {
        return false; //如果未装入文档，则设置OA助手按钮组不可见
    }

    //获取OA传入的按钮组参数组
    var l_grpButtonParams = GetDocParamsValue(l_Doc, constStrEnum.buttonGroups); //disableBtns
    l_grpButtonParams = l_grpButtonParams + "," + GetDocParamsValue(l_Doc, constStrEnum.disableBtns);


    // 要求OA传入控制自定义按钮显示的参数为字符串 中间用 , 分隔开
    if (typeof(l_grpButtonParams) == "string") {
        var l_arrayGroup = new Array();
        l_arrayGroup = l_grpButtonParams.split(",");
        //console.log(l_grpButtonParams);

        // 判断当前按钮是否存在于数组
        if (l_arrayGroup.indexOf(CtrlID) >= 0) {
            return false;
        }
    }
    // 添加OA菜单判断
    if (CtrlID == "WPSWorkExtTab") {
        if(wps.WpsApplication().ActiveDocument){
            let l_value=GetDocParamsValue(wps.WpsApplication().ActiveDocument,"isOA");
            return l_value?true:false;
        }
        var l_value = wps.PluginStorage.getItem(constStrEnum.ShowOATabDocActive);
        wps.PluginStorage.setItem(constStrEnum.ShowOATabDocActive, false); //初始化临时状态变量
        console.log("菜单：" + l_value);
        return l_value;
    }
    return true;
}

/**
 * 根据传入Document对象，获取OA传入的参数的某个Key值的Value
 * @param {*} Doc 
 * @param {*} Key 
 * 返回值：返回指定 Key的 Value
 */
function GetDocParamsValue(Doc, Key) {
    if (!Doc) {
        return "";
    }

    var l_Params = wps.PluginStorage.getItem(Doc.DocID);
    if (!l_Params) {
        return "";
    }

    var l_objParams = JSON.parse(l_Params);
    if (typeof(l_objParams) == "undefined") {
        return "";
    }

    var l_rtnValue = l_objParams[Key];
    if (typeof(l_rtnValue) == "undefined" || l_rtnValue == null) {
        return "";
    }
    return l_rtnValue;
}

/**
 * 获取对象中指定属性的值
 * @param {*} params 
 * @param {*} Key 
 */
function GetParamsValue(Params, Key) {
    if (typeof(Params) == "undefined") {
        return "";
    }

    var l_rtnValue = Params[Key];
    return l_rtnValue;
}



/**
 *  作用：插入二维码图片
 */
function OnInsertQRCode() {
    OnShowDialog("QRCode.html", "插入二维码", 400, 400);
}


/**
 *   打开本地文档并插入到当前文档中指定位置（导入文档）
 */
function OnOpenLocalFile() {
    OpenLocalFile();
}
/**
 *   插入水印
 */
function DoInsertWaterToDoc(){
    var app, shapeRange;
    try {
        // app = wpsFrame.Application;
        var app=wps.WpsApplication();
        var doc = app.ActiveDocument;
        var selection = doc.ActiveWindow.Selection;
        var pageCount = app.ActiveWindow.ActivePane.Pages.Count;
        for(var i=1;i<=pageCount;i++){
            selection.GoTo(1, 1, i);
            app.ActiveWindow.ActivePane.View.SeekView=9;
            app.ActiveDocument.Sections.Item(1).Headers.Item(1).Shapes.AddTextEffect(0, "公司绝密", "华文新魏", 36, false, false, 0, 0).Select();
            shapeRange = app.Selection.ShapeRange;
            shapeRange.TextEffect.NormalizedHeight = false;
            shapeRange.Line.Visible = false;
            shapeRange.Fill.Visible = true;
            shapeRange.Fill.Solid();
            shapeRange.Fill.ForeColor.RGB = 12632256;       /* WdColor枚举 wdColorGray25 代表颜色值 */
            shapeRange.Fill.Transparency = 0.5;             /* 填充透明度，值为0.0~1.0 */
            shapeRange.LockAspectRatio = true;
            shapeRange.Height = 4.58 * 28.346;
            shapeRange.Width = 28.07 * 28.346;
            shapeRange.Rotation = 315;                      /* 图形按照Z轴旋转度数，正值为顺时针旋转，负值为逆时针旋转 */
            shapeRange.WrapFormat.AllowOverlap = true;
            shapeRange.WrapFormat.Side = 3;                 /* WdWrapSideType枚举 wdWrapLargest 形状距离页边距最远的一侧 */
            shapeRange.WrapFormat.Type = 3;                 
            shapeRange.RelativeHorizontalPosition = 0;      
            shapeRange.RelativeVerticalPosition = 0;        
            shapeRange.Left = '-999995';                   
            shapeRange.Top = '-999995';                     
           
        }                  /* WdShapePosition枚举 wdShapeCenter 形状的位置在中央 */
        selection.GoTo(1, 1, 1);
        app.ActiveWindow.ActivePane.View.SeekView=0;
    } catch (error) {
        alert(error.message);
    }
}

/**
 * 插入电子印章的功能
 */
function OnInsertSeal() {
    OnShowDialog("selectSeal.html", "印章", 730, 500);
}

/**
 * 导入模板到文档中 
 */
function OnImportTemplate() {
    OnShowDialog("importTemplate.html", "导入模板", 560, 400);
}


//自定义菜单按钮的点击执行事件
function OnAction(control) {
    var eleId;
    if (typeof control == "object" && arguments.length == 1) { //针对Ribbon的按钮的
        eleId = control.Id;
    } else if (typeof control == "undefined" && arguments.length > 1) { //针对idMso的
        eleId = arguments[1].Id;
        console.log(eleId)
    } else if (typeof control == "boolean" && arguments.length > 1) { //针对checkbox的
        eleId = arguments[1].Id;
    } else if (typeof control == "number" && arguments.length > 1) { //针对combox的
        eleId = arguments[2].Id;
    }
    switch (eleId) {
        case "btnOpenWPSYUN": //打开WPS云文档入口
            pDoOpenWPSCloundDoc();
            break;
        case "btnOpenLocalWPSYUN": //打开本地文档并插入到文档中
            OnOpenLocalFile();
            break;
        case "WPSWorkExtTab":
            OnbtnTabClick();
            break;
        case "btnSaveToServer": //保存到OA服务器
            wps.PluginStorage.setItem(constStrEnum.Save2OAShowConfirm, true)
            OnBtnSaveToServer();
            break;
        case "btnSaveAsFile": //另存为本地文件
            OnBtnSaveAsLocalFile();
            break;
        case "btnChangeToPDF": //转PDF文档并上传
            OnDoChangeToOtherDocFormat(".pdf");
            break;
        case "btnChangeToUOT": //转UOF文档并上传
            OnDoChangeToOtherDocFormat(".uof");
            break;
        case "btnChangeToOFD": //转OFD文档并上传
            OnDoChangeToOtherDocFormat(".ofd");
            break;
            //------------------------------------
        case "btnInsertRedHeader": //插入红头
            OnInsertRedHeaderClick(); //套红头功能
            break;
        case "btnUploadOABackup": //文件备份
            OnUploadOABackupClicked();
            break;
        case "btnInsertSeal": //插入印章
            OnInsertSeal();
            break;
            //------------------------------------
            //修订按钮组
        case "btnClearRevDoc": //执行 清稿 按钮
            OnBtnClearRevDoc();
            break;
        case "btnOpenRevision": //打开修订
            {
                let bFlag = wps.PluginStorage.getItem(constStrEnum.RevisionEnableFlag)
                wps.PluginStorage.setItem(constStrEnum.RevisionEnableFlag, !bFlag)
                //通知wps刷新以下几个按钮的状态
                wps.ribbonUI.InvalidateControl("btnOpenRevision")
                wps.ribbonUI.InvalidateControl("btnCloseRevision")
                OnOpenRevisions(); //
                break;
            }
        case "btnCloseRevision": //关闭修订
            {
                let bFlag = wps.PluginStorage.getItem(constStrEnum.RevisionEnableFlag)
                wps.PluginStorage.setItem(constStrEnum.RevisionEnableFlag, !bFlag)
                //通知wps刷新以下几个按钮的状态
                wps.ribbonUI.InvalidateControl("btnOpenRevision")
                wps.ribbonUI.InvalidateControl("btnCloseRevision")
                OnCloseRevisions();
                break;
            }
        case "btnShowRevision":
            break;
        case "btnAcceptAllRevisions": //接受所有修订功能
            OnAcceptAllRevisions();
            break;
        case "btnRejectAllRevisions": //拒绝修订
            OnRejectAllRevisions();
            break;
            //------------------------------------
        case "btnInsertPic": //插入图片
            DoInsertPicToDoc();
            break;
        case "btnInsertWater":
            DoInsertWaterToDoc()
        case "btnInsertDate": //插入日期
            OnInsertDateClicked();
            break;
        case "btnOpenScan": //打开扫描仪
            OnOpenScanBtnClicked();
            break;
        case "btnPageSetup": //打开页面设置
            OnPageSetupClicked();
            break;
        case "btnQRCode": //插入二维码
            OnInsertQRCode(); //
            break;
        case "btnPrintDOC": // 打开打印设置
            OnPrintDocBtnClicked();
            break;
        case "lblDocSourceValue": //OA公文提示
            OnOADocInfo();
            break;
        case "btnUserName": //点击用户
            OnUserNameSetClick();
            break;
        case "btnInsertBookmark": //插入书签
            OnInsertBookmarkToDoc();
            break;
        case "btnImportTemplate": //导入模板
            OnImportTemplate();
            break;
        case "FileSaveAsMenu": //通过idMso进行「另存为」功能的自定义
        case "FileSaveAs":
            {
                if (pCheckIfOADoc()) { //文档来源是业务系统的，做自定义
                    alert("这是OA文档，将Ctrl+S动作做了重定义，可以调用OA的保存文件流到业务系统的接口。")
                    OnBtnSaveToServer();
                } else { //本地的文档，期望不做自定义，通过转调idMso的方法实现
                    wps.WpsApplication().CommandBars.ExecuteMso("FileSaveAsWordDocx");
                    //此处一定不能去调用与重写idMso相同的ID，否则就是个无线递归了，即在这个场景下不可调用FileSaveAs和FileSaveAsMenu这两个方法
                }
                break;
            }
        case "FileSave": //通过idMso进行「保存」功能的自定义
            {
                if (pCheckIfOADoc()) { //文档来源是业务系统的，做自定义
                    alert("这是OA文档，将Ctrl+S动作做了重定义，可以调用OA的保存文件流到业务系统的接口。")
                    OnBtnSaveToServer();
                } else { //本地的文档，期望不做自定义，通过转调idMso的方法实现
                    // wps.WpsApplication().CommandBars.ExecuteMso("FileSave");
                    wps.WpsApplication().CommandBars.ExecuteMso("SaveAll");
                    //此处一定不能去调用与重写idMso相同的ID，否则就是个无线递归了，即在这个场景下不可调用FileSaveAs和FileSaveAsMenu这两个方法
                }
                break;
            }
        case "FileNew":
        case "FileNewMenu":
        case "WindowNew":
        case "FileNewBlankDocument":
            {
                if (pCheckIfOADoc()) { //文档来源是业务系统的，做自定义
                    alert("这是OA文档，将Ctrl+N动作做了禁用")
                }
            }
            break
        case "ShowAlert_ContextMenuText":
            {
                let selectText = wps.WpsApplication().Selection.Text;
                alert("您选择的内容是：\n" + selectText);
                break;
            }
        case "btnSendMessage1":
            {
                 /**
                 * 内部封装了主动响应前端发送的请求的方法
                 */
                //参数自定义，这里只是负责传递参数，在WpsInvoke.RegWebNotify方法的回调函数中去做接收，自行解析参数
                let params={
                    type:'executeFunc1',
                    message:"当前时间为：" + currentTime()
                }
                /**
                 * WebNotify:
                 * 参数1：发送给业务系统的消息
                 * 参数2：是否将消息加入队列，是否防止丢失消息，都需要设置为true
                 */
                wps.OAAssist.WebNotify(JSON.stringify(params),true); //如果想传一个对象，则使用JSON.stringify方法转成对象字符串。
                break;
            }
        case "btnSendMessage2":
            {
                /**
                 * 内部封装了主动响应前端发送的请求的方法
                 */
                let msgInfo =
                {
                     id: 1,
                     name: 'kingsoft',
                     since: "1988"
                }
                //参数自定义，这里只是负责传递参数，在WpsInvoke.RegWebNotify方法的回调函数中去做接收，自行解析参数
                
                let params={
                    type:'executeFunc2',
                    message:"当前时间为：" + currentTime(),
                    msgInfoStr: JSON.stringify(msgInfo)
                }
                 /**
                 * WebNotify:
                 * 参数1：发送给业务系统的消息
                 * 参数2：是否将消息加入队列，是否防止丢失消息，都需要设置为true
                 */
                wps.OAAssist.WebNotify(JSON.stringify(params),true); //如果想传一个对象，则使用JSON.stringify方法转成对象字符串。
                break;
            }
        case "btnAddWebShape":
            {                
                let l_doc = wps.WpsApplication().ActiveDocument;
                l_doc.Shapes.AddWebShape("https://www.wps.cn");
                break;
            }
        default:
            break;
    }
    return true;
}

/**
 * 作用：重新设置当前用户名称
 */
function OnUserNameSetClick() {
    var l_UserPageUrl = "setUserName.html"
    OnShowDialog(l_UserPageUrl, "OA助手用户名称设置", 500, 300);
}
/**
 * 作用：展示当前文档，被OA助手打开后的，操作记录及相关附加信息
 */
function OnOADocInfo() {
    return;
}

/**
 * 作用：自定义菜单按钮的图标
 */
function GetImage(control) {
    var eleId;
    if (typeof control == "object" && arguments.length == 1) { //针对Ribbon的按钮的
        eleId = control.Id;
    } else if (typeof control == "undefined" && arguments.length > 1) { //针对idMso的
        eleId = arguments[1].Id;
    } else if (typeof control == "boolean" && arguments.length > 1) { //针对checkbox的
        eleId = arguments[1].Id;
    } else if (typeof control == "number" && arguments.length > 1) { //针对combox的
        eleId = arguments[2].Id;
    }
    switch (eleId) {
        case "btnOpenWPSYUN":
            return "./icon/w_WPSCloud.png"; //打开WPS云文档
        case "btnOpenLocalWPSYUN": //导入文件
            return "./icon/w_ImportDoc.png"
        case "btnSaveToServer": //保存到OA后台服务端
            return "./icon/w_Save.png";
        case "btnSaveAsFile": //另存为本地文件
            return "./icon/w_SaveAs.png";
        case "btnChangeToPDF": //输出为PDF格式
            return "./icon/w_PDF.png";
        case "btnChangeToUOT": //
            return "./icon/w_DocUOF.png";
        case "btnChangeToOFD": //转OFD上传
            return "./icon/w_DocOFD.png"; //
        case "btnInsertRedHeader": //套红头
            return "./icon/w_GovDoc.png";
        case "btnInsertSeal": //印章
            return "./icon/c_seal.png";
        case "btnClearRevDoc": //清稿
            return "./icon/w_DocClear.png"
        case "btnUploadOABackup": //备份正文
            return "./icon/w_BackDoc.png";
        case "btnOpenRevision": //打开 修订
        case "btnShowRevision": //
            return "./icon/w_OpenRev.png";
        case "btnCloseRevision": //关闭修订
            return "./icon/w_CloseRev.png";
        case "btnAcceptAllRevisions": // 接受修订
            return "./icon/w_AcceptRev.png";
        case "btnRejectAllRevisions": // 拒绝修订
            return "./icon/w_RejectRev.png";
        case "btnSaveAsFile":
            return "";
        case "btnInsertWater":
        case "btnInsertPic": //插入图片
            return "./icon/w_InsPictures.png";
        case "btnOpenScan": //打开扫描仪
            return "./icon/w_Scanner16.png"; //
        case "btnPageSetup": //打开页面设置
            return "./icon/w_PageGear.png";
        case "btnInsertDate": //插入日期
            return "./icon/w_InsDate.png";
        case "btnQRCode": //二维码
            return "./icon/w_DocQr.png";
        case "btnPrintDOC": // 打印设置
            return "./icon/c_printDoc.png";
        case "btnInsertBookmark":
            return "./icon/c_bookmark.png";
        case "btnImportTemplate":
            return "./icon/w_ImportDoc.png";
        case "btnSendMessage1":
            return "./icon/3.svg"
        case "btnSendMessage2":
            return "./icon/3.svg"
        default:
            ;
    }
    return "./icon/c_default.png";
}

function pGetOpenRevisionButtonLabel() {
    return "打开修订";
}

function pGetShowRevisionButtonLabel() {
    return "显示修订";
}


//xml文件中自定义按钮的文字处理函数
function OnGetLabel(control) {
    var eleId;
    if (typeof control == "object" && arguments.length == 1) { //针对Ribbon的按钮的
        eleId = control.Id;
    } else if (typeof control == "undefined" && arguments.length > 1) { //针对idMso的
        eleId = arguments[1].Id;
    } else if (typeof control == "boolean" && arguments.length > 1) { //针对checkbox的
        eleId = arguments[1].Id;
    } else if (typeof control == "number" && arguments.length > 1) { //针对combox的
        eleId = arguments[2].Id;
    }
    switch (eleId) {
        case "btnOpenWPSYUN": //打开WPS云文档
            return "WPS云文档";
        case "btnOpenLocalWPSYUN": //打开本地云文档目录
            return "导入文档";
        case "btnSaveAsFile":
            return "另存为本地";
        case "btnChangeToPDF": //转PDF并上传
            return "转PDF上传";
        case "btnChangeToUOT": //转UOF并上传
            return "转UOF上传";
        case "btnChangeToOFD": //转OFD格式并上传
            return "转OFD上传";
        case "lblDocSourceValue": //文件来源标签：
            return pGetDocSourceLabel();
        case "lblUserName": //用户名：lableControl 控件
            return "编辑人:"; //pSetUserNameLabelControl();
        case "btnUserName":
            return pSetUserNameLabelControl();
            //======================================================
        case "btnInsertRedHeader": //套红头
            return "套红头";
        case "btnInsertSeal": //插入印章
            return "印章";
        case "btnUploadOABackup": //文件备份
            return "文件备份";
            //======================================================
        case "btnOpenRevision": //打开修订按钮
            return pGetOpenRevisionButtonLabel();
        case "btnShowRevision": //显示修订按钮
            return pGetShowRevisionButtonLabel();
        case "btnCloseRevision": //关闭修订按钮
            return "关闭修订";
        case "btnClearRevDoc": //显示 清稿 
            return "清稿";
        case "btnAcceptAllRevisions": //显示 接受修订
            return "接受修订";
        case "btnRejectAllRevisions": //显示 拒绝修订
            return "拒绝修订";
        case "lblDocLandMode": //显示 文档落地方式 ：不落地还是本地，包括是否受保护
            return pGetOADocLabel();
            //---------------------------------------------
        case "btnInsertPic": //插入图片
            return "插图片";
        case "btnInsertDate": //插入日期
            return "插日期";
        case "btnOpenScan": //打开扫描仪
            return "扫描仪";
        case "btnInsertWater":
            return "插入水印"
        case "btnPageSetup": //打开页面设置
            return "页面设置";
        case "btnPrintDOC": //打开页面设置
            return "打印设置";
        case "btnInsertBookmark":
            return "导入书签";
        case "btnImportTemplate":
            return "导入模板";
        default:
            ;
    }
    return "";
}

/**
 * 作用：处理Ribbon按钮的是否可显示
 * @param {*} control  ：Ribbon 的按钮控件
 */
function OnGetVisible(control) {
    var eleId;
    if (typeof control == "object" && arguments.length == 1) { //针对Ribbon的按钮的
        eleId = control.Id;
    } else if (typeof control == "undefined" && arguments.length > 1) { //针对idMso的
        eleId = arguments[1].Id;
    } else if (typeof control == "boolean" && arguments.length > 1) { //针对checkbox的
        eleId = arguments[1].Id;
    } else if (typeof control == "number" && arguments.length > 1) { //针对combox的
        eleId = arguments[2].Id;
    }
    var l_value = false;

    //关闭一些测试中的功能
    switch (eleId) {
        case "lblDocLandMode": //文档落地标签
            return true;
        case "btnOpenScan":
            return false;
        case "btnAddWebShape":
            {
                if (wps.WpsApplication().Build.toString().indexOf("11.1") != -1){
                    return true;
                }
                return false;
            }
            break;
        default:

    }

    //按照 OA文档传递过来的属性进行判断
    l_value = pShowRibbonGroupByOADocParam(eleId);
    return l_value;
}

/**
 * 作用：处理Ribbon按钮的是否可用
 * @param {*} control  ：Ribbon 的按钮控件
 */
function OnGetEnabled(control) {
    var eleId;
    if (typeof control == "object" && arguments.length == 1) { //针对Ribbon的按钮的
        eleId = control.Id;
    } else if (typeof control == "undefined" && arguments.length > 1) { //针对idMso的
        eleId = arguments[1].Id;
    } else if (typeof control == "boolean" && arguments.length > 1) { //针对checkbox的
        eleId = arguments[1].Id;
    } else if (typeof control == "number" && arguments.length > 1) { //针对combox的
        eleId = arguments[2].Id;
    }
    switch (eleId) {
        case "btnSaveToServer": //保存到OA服务器的相关按钮。判断，如果非OA文件，禁止点击
        case "btnChangeToPDF": //保存到PDF格式再上传
        case "btnChangeToUOT": //保存到UOT格式再上传
        case "btnChangeToOFD": //保存到OFD格式再上传
        case "SaveAll": //保存所有文档
        //以下四个idMso的控制是关于文档新建的
        case "FileNew":
        case "FileNewMenu":
        case "WindowNew":
        case "FileNewBlankDocument":
            return OnSetSaveToOAEnable();
        case "btnCloseRevision":
            {
                let bFlag = wps.PluginStorage.getItem(constStrEnum.RevisionEnableFlag)
                return bFlag
            }
        case "btnOpenRevision":
            {
                let bFlag = wps.PluginStorage.getItem(constStrEnum.RevisionEnableFlag)
                return !bFlag
            }
        case "PictureInsert":
            return false;
        case "TabInsert"://WPS自身tab：插入
        case "TabDeveloper": //WPS自身tab：开发工具
        // case "TabPageLayoutWord": //WPS自身tab：页面布局
        // case "TabReferences": //WPS自身tab：引用
        // case "TabReviewWord": //WPS自身tab：审阅
        // case "TabView": //WPS自身tab：视图
            {
                if(pCheckIfOADoc()){
                    return false;//如果是OA打开的文档，把这个几个tab不可用/隐藏
                }else{
                    return true;
                }
            }
        default:
            ;
    }
    return true;
}