在菜单上添加自定义按钮的相关事件

OnCustomButtonOnMenuCmd

语法

javascript

OnCustomButtonOnMenuCmd(btnPos, btnCaption, btnID)

参数

名称	必选/可选	数据类型	说明
btnPos	必选	long	自定义菜单按钮位置
btnCaption	必选	string	自定义菜单按钮名称
btnID	必选	long	自定义菜单按钮ID

说明

该事件在用户单击菜单上的自定义按钮时执行。各个参数的含义请参考AddCustomButtonOnMenu方法。

注意：在事件中可以通过判断btnPos和btnCaption或者btnID，在对点击按钮事件进行相应操作。

示例代码

javascript

// 自定义菜单按钮命令事件处理
function OnCustomButtonOnMenuCmd(btnPos, btnCaption, btnID) {
    console.log("自定义菜单按钮命令事件触发");
    console.log("按钮位置：", btnPos);
    console.log("按钮标题：", btnCaption);
    console.log("按钮ID：", btnID);
    
    // 根据按钮ID处理不同操作
    switch(btnID) {
        case 400:
            handleQuickSave();
            break;
        case 401:
            handleQuickPrint();
            break;
        case 402:
            handleQuickExport();
            break;
        case 403:
            handleQuickImport();
            break;
        case 404:
            handleQuickPreview();
            break;
        default:
            console.log("未知按钮命令：", btnID);
    }
    
    // 根据按钮标题处理操作
    switch(btnCaption) {
        case "快速保存":
            handleQuickSave();
            break;
        case "快速打印":
            handleQuickPrint();
            break;
        case "快速导出":
            handleQuickExport();
            break;
        case "快速导入":
            handleQuickImport();
            break;
        case "快速预览":
            handleQuickPreview();
            break;
        default:
            console.log("未知按钮标题：", btnCaption);
    }
}

// 处理快速保存
function handleQuickSave() {
    console.log("执行快速保存操作");
    try {
        // 执行保存操作
        OCX_OBJ.Save();
        console.log("快速保存成功");
        showSuccessMessage("文档保存成功");
    } catch (error) {
        console.error("快速保存失败：", error);
        showErrorMessage("文档保存失败：" + error.message);
    }
}

// 处理快速打印
function handleQuickPrint() {
    console.log("执行快速打印操作");
    try {
        // 执行打印操作
        OCX_OBJ.Print();
        console.log("快速打印成功");
        showSuccessMessage("文档打印成功");
    } catch (error) {
        console.error("快速打印失败：", error);
        showErrorMessage("文档打印失败：" + error.message);
    }
}

// 处理快速导出
function handleQuickExport() {
    console.log("执行快速导出操作");
    try {
        // 显示导出选项
        showExportOptions();
    } catch (error) {
        console.error("快速导出失败：", error);
        showErrorMessage("文档导出失败：" + error.message);
    }
}

// 处理快速导入
function handleQuickImport() {
    console.log("执行快速导入操作");
    try {
        // 显示导入选项
        showImportOptions();
    } catch (error) {
        console.error("快速导入失败：", error);
        showErrorMessage("文档导入失败：" + error.message);
    }
}

// 处理快速预览
function handleQuickPreview() {
    console.log("执行快速预览操作");
    try {
        // 执行预览操作
        OCX_OBJ.PrintPreview();
        console.log("快速预览成功");
    } catch (error) {
        console.error("快速预览失败：", error);
        showErrorMessage("文档预览失败：" + error.message);
    }
}

完整示例

菜单按钮事件管理器

javascript

// 菜单按钮事件管理器
class MenuButtonEventManager {
    constructor() {
        this.buttonHandlers = new Map();
        this.buttonStates = new Map();
        this.initButtonHandlers();
    }
    
    // 初始化按钮处理器
    initButtonHandlers() {
        // 快速保存按钮
        this.buttonHandlers.set(400, {
            name: "快速保存",
            handler: this.handleQuickSave.bind(this),
            enabled: true
        });
        
        // 快速打印按钮
        this.buttonHandlers.set(401, {
            name: "快速打印",
            handler: this.handleQuickPrint.bind(this),
            enabled: true
        });
        
        // 快速导出按钮
        this.buttonHandlers.set(402, {
            name: "快速导出",
            handler: this.handleQuickExport.bind(this),
            enabled: true
        });
        
        // 快速导入按钮
        this.buttonHandlers.set(403, {
            name: "快速导入",
            handler: this.handleQuickImport.bind(this),
            enabled: true
        });
        
        // 快速预览按钮
        this.buttonHandlers.set(404, {
            name: "快速预览",
            handler: this.handleQuickPreview.bind(this),
            enabled: true
        });
    }
    
    // 处理按钮点击事件
    handleButtonClick(btnPos, btnCaption, btnID) {
        console.log("处理按钮点击事件：", btnCaption, btnID);
        
        // 检查按钮是否存在
        if (!this.buttonHandlers.has(btnID)) {
            console.warn("未知按钮ID：", btnID);
            return;
        }
        
        // 获取按钮信息
        var buttonInfo = this.buttonHandlers.get(btnID);
        
        // 检查按钮是否启用
        if (!buttonInfo.enabled) {
            console.warn("按钮已禁用：", btnCaption);
            showWarningMessage("该功能当前不可用");
            return;
        }
        
        // 执行按钮处理函数
        try {
            buttonInfo.handler(btnPos, btnCaption, btnID);
        } catch (error) {
            console.error("按钮处理失败：", error);
            showErrorMessage("操作失败：" + error.message);
        }
    }
    
    // 处理快速保存
    handleQuickSave(btnPos, btnCaption, btnID) {
        console.log("执行快速保存");
        
        // 检查文档是否已修改
        if (this.isDocumentModified()) {
            // 执行保存操作
            this.performSave();
        } else {
            showInfoMessage("文档未修改，无需保存");
        }
    }
    
    // 处理快速打印
    handleQuickPrint(btnPos, btnCaption, btnID) {
        console.log("执行快速打印");
        
        // 检查打印机是否可用
        if (this.isPrinterAvailable()) {
            // 执行打印操作
            this.performPrint();
        } else {
            showErrorMessage("打印机不可用");
        }
    }
    
    // 处理快速导出
    handleQuickExport(btnPos, btnCaption, btnID) {
        console.log("执行快速导出");
        
        // 显示导出选项对话框
        this.showExportDialog();
    }
    
    // 处理快速导入
    handleQuickImport(btnPos, btnCaption, btnID) {
        console.log("执行快速导入");
        
        // 显示导入选项对话框
        this.showImportDialog();
    }
    
    // 处理快速预览
    handleQuickPreview(btnPos, btnCaption, btnID) {
        console.log("执行快速预览");
        
        // 执行预览操作
        this.performPreview();
    }
    
    // 检查文档是否已修改
    isDocumentModified() {
        try {
            // 检查文档修改状态
            return OCX_OBJ.IsDocumentModified || false;
        } catch (error) {
            console.error("检查文档修改状态失败：", error);
            return false;
        }
    }
    
    // 执行保存操作
    performSave() {
        try {
            OCX_OBJ.Save();
            console.log("文档保存成功");
            showSuccessMessage("文档保存成功");
            
            // 更新按钮状态
            this.updateButtonStates();
        } catch (error) {
            console.error("文档保存失败：", error);
            showErrorMessage("文档保存失败：" + error.message);
        }
    }
    
    // 检查打印机是否可用
    isPrinterAvailable() {
        try {
            // 检查打印机状态
            return true; // 简化实现
        } catch (error) {
            console.error("检查打印机状态失败：", error);
            return false;
        }
    }
    
    // 执行打印操作
    performPrint() {
        try {
            OCX_OBJ.Print();
            console.log("文档打印成功");
            showSuccessMessage("文档打印成功");
        } catch (error) {
            console.error("文档打印失败：", error);
            showErrorMessage("文档打印失败：" + error.message);
        }
    }
    
    // 显示导出对话框
    showExportDialog() {
        console.log("显示导出对话框");
        // 实现导出对话框逻辑
        var exportOptions = {
            formats: ['PDF', 'DOCX', 'XLSX', 'PPTX'],
            defaultFormat: 'PDF'
        };
        
        // 显示导出选项
        showExportOptions(exportOptions);
    }
    
    // 显示导入对话框
    showImportDialog() {
        console.log("显示导入对话框");
        // 实现导入对话框逻辑
        var importOptions = {
            formats: ['DOCX', 'XLSX', 'PPTX', 'TXT'],
            defaultFormat: 'DOCX'
        };
        
        // 显示导入选项
        showImportOptions(importOptions);
    }
    
    // 执行预览操作
    performPreview() {
        try {
            OCX_OBJ.PrintPreview();
            console.log("文档预览成功");
        } catch (error) {
            console.error("文档预览失败：", error);
            showErrorMessage("文档预览失败：" + error.message);
        }
    }
    
    // 更新按钮状态
    updateButtonStates() {
        // 根据文档状态更新按钮状态
        var documentState = this.getDocumentState();
        
        // 更新快速保存按钮状态
        this.updateButtonState(400, documentState.canSave);
        
        // 更新快速打印按钮状态
        this.updateButtonState(401, documentState.canPrint);
        
        // 更新快速导出按钮状态
        this.updateButtonState(402, documentState.canExport);
        
        // 更新快速导入按钮状态
        this.updateButtonState(403, documentState.canImport);
        
        // 更新快速预览按钮状态
        this.updateButtonState(404, documentState.canPreview);
    }
    
    // 获取文档状态
    getDocumentState() {
        return {
            canSave: this.isDocumentModified(),
            canPrint: this.isPrinterAvailable(),
            canExport: true,
            canImport: true,
            canPreview: true
        };
    }
    
    // 更新按钮状态
    updateButtonState(btnID, enabled) {
        if (this.buttonHandlers.has(btnID)) {
            this.buttonHandlers.get(btnID).enabled = enabled;
            console.log("按钮状态已更新：", btnID, enabled);
        }
    }
    
    // 启用按钮
    enableButton(btnID) {
        this.updateButtonState(btnID, true);
    }
    
    // 禁用按钮
    disableButton(btnID) {
        this.updateButtonState(btnID, false);
    }
    
    // 获取按钮状态
    getButtonState(btnID) {
        if (this.buttonHandlers.has(btnID)) {
            return this.buttonHandlers.get(btnID).enabled;
        }
        return false;
    }
}

// 创建菜单按钮事件管理器实例
const menuButtonEventManager = new MenuButtonEventManager();

// 全局事件处理函数
function OnCustomButtonOnMenuCmd(btnPos, btnCaption, btnID) {
    menuButtonEventManager.handleButtonClick(btnPos, btnCaption, btnID);
}

按钮状态管理

javascript

// 按钮状态管理器
class ButtonStateManager {
    constructor() {
        this.buttonStates = new Map();
        this.documentState = {
            isOpen: false,
            isModified: false,
            isReadOnly: false,
            hasContent: false
        };
    }
    
    // 更新文档状态
    updateDocumentState() {
        try {
            this.documentState.isOpen = OCX_OBJ.IsDocumentOpen || false;
            this.documentState.isModified = OCX_OBJ.IsDocumentModified || false;
            this.documentState.isReadOnly = OCX_OBJ.IsReadOnly || false;
            this.documentState.hasContent = OCX_OBJ.HasContent || false;
            
            console.log("文档状态已更新：", this.documentState);
            
            // 根据文档状态更新按钮状态
            this.updateButtonStates();
        } catch (error) {
            console.error("更新文档状态失败：", error);
        }
    }
    
    // 更新按钮状态
    updateButtonStates() {
        // 快速保存按钮
        this.updateButtonState(400, this.documentState.isOpen && this.documentState.isModified && !this.documentState.isReadOnly);
        
        // 快速打印按钮
        this.updateButtonState(401, this.documentState.isOpen && this.documentState.hasContent);
        
        // 快速导出按钮
        this.updateButtonState(402, this.documentState.isOpen && this.documentState.hasContent);
        
        // 快速导入按钮
        this.updateButtonState(403, this.documentState.isOpen && !this.documentState.isReadOnly);
        
        // 快速预览按钮
        this.updateButtonState(404, this.documentState.isOpen && this.documentState.hasContent);
    }
    
    // 更新按钮状态
    updateButtonState(btnID, enabled) {
        this.buttonStates.set(btnID, enabled);
        console.log("按钮状态已更新：", btnID, enabled);
    }
    
    // 获取按钮状态
    getButtonState(btnID) {
        return this.buttonStates.get(btnID) || false;
    }
    
    // 启用按钮
    enableButton(btnID) {
        this.updateButtonState(btnID, true);
    }
    
    // 禁用按钮
    disableButton(btnID) {
        this.updateButtonState(btnID, false);
    }
    
    // 检查按钮是否启用
    isButtonEnabled(btnID) {
        return this.getButtonState(btnID);
    }
}

// 创建按钮状态管理器实例
const buttonStateManager = new ButtonStateManager();

// 定期更新按钮状态
setInterval(function() {
    buttonStateManager.updateDocumentState();
}, 1000); // 每秒更新一次

按钮功能增强

javascript

// 按钮功能增强器
class ButtonFeatureEnhancer {
    constructor() {
        this.features = new Map();
        this.initFeatures();
    }
    
    // 初始化功能
    initFeatures() {
        this.features.set('quickSave', {
            enabled: true,
            shortcut: 'Ctrl+S',
            description: '快速保存文档'
        });
        
        this.features.set('quickPrint', {
            enabled: true,
            shortcut: 'Ctrl+P',
            description: '快速打印文档'
        });
        
        this.features.set('quickExport', {
            enabled: true,
            shortcut: 'Ctrl+E',
            description: '快速导出文档'
        });
        
        this.features.set('quickImport', {
            enabled: true,
            shortcut: 'Ctrl+I',
            description: '快速导入文档'
        });
        
        this.features.set('quickPreview', {
            enabled: true,
            shortcut: 'Ctrl+Shift+P',
            description: '快速预览文档'
        });
    }
    
    // 启用功能
    enableFeature(featureName) {
        if (this.features.has(featureName)) {
            this.features.get(featureName).enabled = true;
            console.log("功能已启用：", featureName);
        }
    }
    
    // 禁用功能
    disableFeature(featureName) {
        if (this.features.has(featureName)) {
            this.features.get(featureName).enabled = false;
            console.log("功能已禁用：", featureName);
        }
    }
    
    // 检查功能是否启用
    isFeatureEnabled(featureName) {
        return this.features.has(featureName) && this.features.get(featureName).enabled;
    }
    
    // 获取功能信息
    getFeatureInfo(featureName) {
        return this.features.get(featureName);
    }
    
    // 处理按钮点击
    handleButtonClick(btnID) {
        var featureName = this.getFeatureNameByID(btnID);
        
        if (featureName && this.isFeatureEnabled(featureName)) {
            console.log("执行功能：", featureName);
            this.executeFeature(featureName);
        } else {
            console.warn("功能不可用：", featureName);
            showWarningMessage("该功能当前不可用");
        }
    }
    
    // 根据ID获取功能名称
    getFeatureNameByID(btnID) {
        var featureMap = {
            400: 'quickSave',
            401: 'quickPrint',
            402: 'quickExport',
            403: 'quickImport',
            404: 'quickPreview'
        };
        
        return featureMap[btnID];
    }
    
    // 执行功能
    executeFeature(featureName) {
        switch(featureName) {
            case 'quickSave':
                this.executeQuickSave();
                break;
            case 'quickPrint':
                this.executeQuickPrint();
                break;
            case 'quickExport':
                this.executeQuickExport();
                break;
            case 'quickImport':
                this.executeQuickImport();
                break;
            case 'quickPreview':
                this.executeQuickPreview();
                break;
            default:
                console.warn("未知功能：", featureName);
        }
    }
    
    // 执行快速保存
    executeQuickSave() {
        console.log("执行快速保存");
        // 实现快速保存逻辑
    }
    
    // 执行快速打印
    executeQuickPrint() {
        console.log("执行快速打印");
        // 实现快速打印逻辑
    }
    
    // 执行快速导出
    executeQuickExport() {
        console.log("执行快速导出");
        // 实现快速导出逻辑
    }
    
    // 执行快速导入
    executeQuickImport() {
        console.log("执行快速导入");
        // 实现快速导入逻辑
    }
    
    // 执行快速预览
    executeQuickPreview() {
        console.log("执行快速预览");
        // 实现快速预览逻辑
    }
}

// 创建按钮功能增强器实例
const buttonFeatureEnhancer = new ButtonFeatureEnhancer();

注意事项

事件绑定：
- 确保在HTML中正确绑定事件处理函数
- 事件函数名要与HTML中的属性值一致
- 注意大小写和拼写
参数处理：
- 检查参数的有效性
- 处理可选参数的情况
- 注意参数的数据类型
按钮识别：
- 可以通过按钮ID或按钮标题识别
- 建议使用按钮ID进行识别
- 按钮标题可能因语言设置而变化
状态管理：
- 实现按钮状态管理
- 根据文档状态启用/禁用按钮
- 处理按钮状态变化
错误处理：
- 处理按钮操作失败的情况
- 提供用户友好的错误信息
- 记录操作日志
性能优化：
- 避免在事件处理中执行耗时操作
- 合理使用异步操作
- 避免重复处理
用户体验：
- 提供及时的状态反馈
- 显示操作进度
- 处理用户交互
兼容性：
- 考虑不同浏览器的兼容性
- 处理不同版本的差异
- 测试各种场景

在菜单上添加自定义按钮的相关事件 ​

OnCustomButtonOnMenuCmd ​

语法 ​

参数 ​

说明 ​

示例代码 ​

完整示例 ​

菜单按钮事件管理器 ​

按钮状态管理 ​

按钮功能增强 ​

注意事项 ​

在菜单上添加自定义按钮的相关事件

OnCustomButtonOnMenuCmd

语法

参数

说明

示例代码

完整示例

菜单按钮事件管理器

按钮状态管理

按钮功能增强

注意事项