软航科技文档中心

Appearance

使用JavaScript响应控件事件 ​

基本事件绑定 ​

HTML对象标签配置 ​

html
<object name='webwps' id='webwps_id' type='application/ntko-plug' 
        width='1000' height='600' 
        ForOnDocumentOpened='OnDocumentOpened' 
        ForOnDocumentClosed='OnDocumentClosed'>
</object>

JavaScript事件处理函数 ​

javascript
// 文档打开事件处理
function OnDocumentOpened(doc, file) {
    console.log("OnDocumentOpened成功回调");
    console.log("文档对象：", doc);
    console.log("文件路径：", file);
    
    // 处理文档打开后的操作
    handleDocumentOpened(doc, file);
}

// 文档关闭事件处理
function OnDocumentClosed() {
    console.log("OnDocumentClosed成功回调");
    
    // 处理文档关闭后的操作
    handleDocumentClosed();
}

// 处理文档打开后的操作
function handleDocumentOpened(doc, file) {
    console.log("处理文档打开后的操作");
    
    // 设置文档属性
    setDocumentProperties(doc);
    
    // 加载用户配置
    loadUserSettings();
    
    // 初始化工具栏
    initializeToolbar();
    
    // 更新UI状态
    updateUIState('documentOpened');
}

// 处理文档关闭后的操作
function handleDocumentClosed() {
    console.log("处理文档关闭后的操作");
    
    // 保存用户设置
    saveUserSettings();
    
    // 清理资源
    cleanupResources();
    
    // 更新UI状态
    updateUIState('documentClosed');
}

完整事件绑定示例 ​

文档相关事件 ​

html
<object name='webwps' id='webwps_id' type='application/ntko-plug' 
        width='1000' height='600' 
        ForOnDocumentOpened='OnDocumentOpened'
        ForOnDocumentClosed='OnDocumentClosed'
        ForAfterOpenFromURL='AfterOpenFromURL'
        ForOnFileCommand='OnFileCommand'
        ForOnPublishAsPDFToURL='OnPublishAsPDFToURL'
        ForOnPublishAsOFDToURL='OnPublishAsOFDToURL'>
</object>
javascript
// 文档打开事件
function OnDocumentOpened(doc, file) {
    console.log("文档已打开：", file);
    handleDocumentOpened(doc, file);
}

// 文档关闭事件
function OnDocumentClosed() {
    console.log("文档已关闭");
    handleDocumentClosed();
}

// 从URL打开后事件
function AfterOpenFromURL(doc, statusCode) {
    console.log("从URL打开文档：", statusCode);
    handleAfterOpenFromURL(doc, statusCode);
}

// 文件命令事件
function OnFileCommand(item, isCancel) {
    console.log("文件命令：", item, isCancel);
    handleFileCommand(item, isCancel);
}

// PDF发布事件
function OnPublishAsPDFToURL(retData, errorCode) {
    console.log("PDF发布：", retData, errorCode);
    handlePublishAsPDFToURL(retData, errorCode);
}

// OFD发布事件
function OnPublishAsOFDToURL(retData, errorCode) {
    console.log("OFD发布：", retData, errorCode);
    handlePublishAsOFDToURL(retData, errorCode);
}

菜单相关事件 ​

html
<object name='webwps' id='webwps_id' type='application/ntko-plug' 
        width='1000' height='600' 
        ForOnCustomMenuCmd2='OnCustomMenuCmd2'
        ForOnCustomFileMenuCmd='OnCustomFileMenuCmd'
        ForBeforeOriginalMenuCommand='BeforeOriginalMenuCommand'>
</object>
javascript
// 自定义菜单命令事件
function OnCustomMenuCmd2(menuPos, submenuPos, subsubmenuPos, menuCaption, myMenuID) {
    console.log("自定义菜单命令：", menuCaption, myMenuID);
    handleCustomMenuCommand(menuPos, submenuPos, subsubmenuPos, menuCaption, myMenuID);
}

// 自定义文件菜单命令事件
function OnCustomFileMenuCmd(menuIndex, menuCaption, menuID) {
    console.log("自定义文件菜单命令：", menuCaption, menuID);
    handleCustomFileMenuCommand(menuIndex, menuCaption, menuID);
}

// 原始菜单命令前事件
function BeforeOriginalMenuCommand(menuTitle, isCancel) {
    console.log("原始菜单命令：", menuTitle, isCancel);
    handleBeforeOriginalMenuCommand(menuTitle, isCancel);
}

按钮相关事件 ​

html
<object name='webwps' id='webwps_id' type='application/ntko-plug' 
        width='1000' height='600' 
        ForOnCustomButtonOnMenuCmd='OnCustomButtonOnMenuCmd'
        ForOnCustomToolBarCommand='OnCustomToolBarCommand'>
</object>
javascript
// 自定义菜单按钮命令事件
function OnCustomButtonOnMenuCmd(btnPos, btnCaption, btnID) {
    console.log("自定义菜单按钮命令：", btnCaption, btnID);
    handleCustomButtonOnMenuCmd(btnPos, btnCaption, btnID);
}

// 自定义工具栏按钮命令事件
function OnCustomToolBarCommand(buttonIndex) {
    console.log("自定义工具栏按钮命令：", buttonIndex);
    handleCustomToolBarCommand(buttonIndex);
}

Word相关事件 ​

html
<object name='webwps' id='webwps_id' type='application/ntko-plug' 
        width='1000' height='600' 
        ForOnWordWPSSelChange='OnWordWPSSelChange'
        ForOnWordBeforeRightClick='OnWordBeforeRightClick'>
</object>
javascript
// Word选择变化事件
function OnWordWPSSelChange(selection) {
    console.log("Word选择变化：", selection);
    handleWordSelectionChange(selection);
}

// Word右键事件
function OnWordBeforeRightClick(selection, isCancel) {
    console.log("Word右键事件：", selection, isCancel);
    handleWordBeforeRightClick(selection, isCancel);
}

Excel相关事件 ​

html
<object name='webwps' id='webwps_id' type='application/ntko-plug' 
        width='1000' height='600' 
        ForOnSheetSelectionChange='OnSheetSelectionChange'
        ForOnSheetBeforeDoubleClick='OnSheetBeforeDoubleClick'
        ForOnSheetBeforeRightClick='OnSheetBeforeRightClick'
        ForOnSheetChange='OnSheetChange'>
</object>
javascript
// Excel选择变化事件
function OnSheetSelectionChange(sheetName, row, col) {
    console.log("Excel选择变化：", sheetName, row, col);
    handleSheetSelectionChange(sheetName, row, col);
}

// Excel双击事件
function OnSheetBeforeDoubleClick(sheetName, row, col, isCancel) {
    console.log("Excel双击事件：", sheetName, row, col, isCancel);
    handleSheetBeforeDoubleClick(sheetName, row, col, isCancel);
}

// Excel右键事件
function OnSheetBeforeRightClick(sheetName, row, col, isCancel) {
    console.log("Excel右键事件：", sheetName, row, col, isCancel);
    handleSheetBeforeRightClick(sheetName, row, col, isCancel);
}

// Excel单元格变化事件
function OnSheetChange(sheetName, row, col) {
    console.log("Excel单元格变化：", sheetName, row, col);
    handleSheetChange(sheetName, row, col);
}

事件处理管理器 ​

事件处理管理器类 ​

javascript
// 事件处理管理器
class EventHandlerManager {
    constructor() {
        this.documentHandlers = new Map();
        this.menuHandlers = new Map();
        this.buttonHandlers = new Map();
        this.wordHandlers = new Map();
        this.excelHandlers = new Map();
        this.initHandlers();
    }
    
    // 初始化处理器
    initHandlers() {
        // 文档相关处理器
        this.documentHandlers.set('OnDocumentOpened', this.handleDocumentOpened);
        this.documentHandlers.set('OnDocumentClosed', this.handleDocumentClosed);
        this.documentHandlers.set('AfterOpenFromURL', this.handleAfterOpenFromURL);
        this.documentHandlers.set('OnFileCommand', this.handleFileCommand);
        this.documentHandlers.set('OnPublishAsPDFToURL', this.handlePublishAsPDFToURL);
        this.documentHandlers.set('OnPublishAsOFDToURL', this.handlePublishAsOFDToURL);
        
        // 菜单相关处理器
        this.menuHandlers.set('OnCustomMenuCmd2', this.handleCustomMenuCmd2);
        this.menuHandlers.set('OnCustomFileMenuCmd', this.handleCustomFileMenuCmd);
        this.menuHandlers.set('BeforeOriginalMenuCommand', this.handleBeforeOriginalMenuCommand);
        
        // 按钮相关处理器
        this.buttonHandlers.set('OnCustomButtonOnMenuCmd', this.handleCustomButtonOnMenuCmd);
        this.buttonHandlers.set('OnCustomToolBarCommand', this.handleCustomToolBarCommand);
        
        // Word相关处理器
        this.wordHandlers.set('OnWordWPSSelChange', this.handleWordWPSSelChange);
        this.wordHandlers.set('OnWordBeforeRightClick', this.handleWordBeforeRightClick);
        
        // Excel相关处理器
        this.excelHandlers.set('OnSheetSelectionChange', this.handleSheetSelectionChange);
        this.excelHandlers.set('OnSheetBeforeDoubleClick', this.handleSheetBeforeDoubleClick);
        this.excelHandlers.set('OnSheetBeforeRightClick', this.handleSheetBeforeRightClick);
        this.excelHandlers.set('OnSheetChange', this.handleSheetChange);
    }
    
    // 处理文档打开
    handleDocumentOpened(doc, file) {
        console.log("处理文档打开：", file);
        // 实现文档打开处理逻辑
    }
    
    // 处理文档关闭
    handleDocumentClosed() {
        console.log("处理文档关闭");
        // 实现文档关闭处理逻辑
    }
    
    // 处理从URL打开后
    handleAfterOpenFromURL(doc, statusCode) {
        console.log("处理从URL打开后：", statusCode);
        // 实现从URL打开后处理逻辑
    }
    
    // 处理文件命令
    handleFileCommand(item, isCancel) {
        console.log("处理文件命令：", item, isCancel);
        // 实现文件命令处理逻辑
    }
    
    // 处理PDF发布
    handlePublishAsPDFToURL(retData, errorCode) {
        console.log("处理PDF发布：", retData, errorCode);
        // 实现PDF发布处理逻辑
    }
    
    // 处理OFD发布
    handlePublishAsOFDToURL(retData, errorCode) {
        console.log("处理OFD发布：", retData, errorCode);
        // 实现OFD发布处理逻辑
    }
    
    // 处理自定义菜单命令
    handleCustomMenuCmd2(menuPos, submenuPos, subsubmenuPos, menuCaption, myMenuID) {
        console.log("处理自定义菜单命令：", menuCaption, myMenuID);
        // 实现自定义菜单命令处理逻辑
    }
    
    // 处理自定义文件菜单命令
    handleCustomFileMenuCmd(menuIndex, menuCaption, menuID) {
        console.log("处理自定义文件菜单命令：", menuCaption, menuID);
        // 实现自定义文件菜单命令处理逻辑
    }
    
    // 处理原始菜单命令前
    handleBeforeOriginalMenuCommand(menuTitle, isCancel) {
        console.log("处理原始菜单命令前：", menuTitle, isCancel);
        // 实现原始菜单命令前处理逻辑
    }
    
    // 处理自定义菜单按钮命令
    handleCustomButtonOnMenuCmd(btnPos, btnCaption, btnID) {
        console.log("处理自定义菜单按钮命令：", btnCaption, btnID);
        // 实现自定义菜单按钮命令处理逻辑
    }
    
    // 处理自定义工具栏按钮命令
    handleCustomToolBarCommand(buttonIndex) {
        console.log("处理自定义工具栏按钮命令：", buttonIndex);
        // 实现自定义工具栏按钮命令处理逻辑
    }
    
    // 处理Word选择变化
    handleWordWPSSelChange(selection) {
        console.log("处理Word选择变化：", selection);
        // 实现Word选择变化处理逻辑
    }
    
    // 处理Word右键
    handleWordBeforeRightClick(selection, isCancel) {
        console.log("处理Word右键：", selection, isCancel);
        // 实现Word右键处理逻辑
    }
    
    // 处理Excel选择变化
    handleSheetSelectionChange(sheetName, row, col) {
        console.log("处理Excel选择变化：", sheetName, row, col);
        // 实现Excel选择变化处理逻辑
    }
    
    // 处理Excel双击
    handleSheetBeforeDoubleClick(sheetName, row, col, isCancel) {
        console.log("处理Excel双击：", sheetName, row, col, isCancel);
        // 实现Excel双击处理逻辑
    }
    
    // 处理Excel右键
    handleSheetBeforeRightClick(sheetName, row, col, isCancel) {
        console.log("处理Excel右键：", sheetName, row, col, isCancel);
        // 实现Excel右键处理逻辑
    }
    
    // 处理Excel单元格变化
    handleSheetChange(sheetName, row, col) {
        console.log("处理Excel单元格变化：", sheetName, row, col);
        // 实现Excel单元格变化处理逻辑
    }
}

// 创建事件处理管理器实例
const eventHandlerManager = new EventHandlerManager();

事件处理工具函数 ​

javascript
// 事件处理工具函数
class EventUtils {
    // 创建事件处理函数
    static createEventHandler(handlerName, handler) {
        return function(...args) {
            console.log("事件处理：", handlerName, args);
            try {
                handler.apply(this, args);
            } catch (error) {
                console.error("事件处理失败：", handlerName, error);
            }
        };
    }
    
    // 创建文档事件处理函数
    static createDocumentEventHandler(handlerName, handler) {
        return EventUtils.createEventHandler(handlerName, handler);
    }
    
    // 创建菜单事件处理函数
    static createMenuEventHandler(handlerName, handler) {
        return EventUtils.createEventHandler(handlerName, handler);
    }
    
    // 创建按钮事件处理函数
    static createButtonEventHandler(handlerName, handler) {
        return EventUtils.createEventHandler(handlerName, handler);
    }
    
    // 创建Word事件处理函数
    static createWordEventHandler(handlerName, handler) {
        return EventUtils.createEventHandler(handlerName, handler);
    }
    
    // 创建Excel事件处理函数
    static createExcelEventHandler(handlerName, handler) {
        return EventUtils.createEventHandler(handlerName, handler);
    }
    
    // 批量创建事件处理函数
    static createBatchEventHandlers(handlers) {
        var eventHandlers = {};
        
        handlers.forEach(function(handler) {
            eventHandlers[handler.name] = EventUtils.createEventHandler(
                handler.name,
                handler.handler
            );
        });
        
        return eventHandlers;
    }
}

// 使用示例
var handlers = [
    {
        name: 'OnDocumentOpened',
        handler: function(doc, file) {
            console.log("文档已打开：", file);
        }
    },
    {
        name: 'OnDocumentClosed',
        handler: function() {
            console.log("文档已关闭");
        }
    },
    {
        name: 'OnCustomMenuCmd2',
        handler: function(menuPos, submenuPos, subsubmenuPos, menuCaption, myMenuID) {
            console.log("自定义菜单命令：", menuCaption, myMenuID);
        }
    }
];

var eventHandlers = EventUtils.createBatchEventHandlers(handlers);

完整示例 ​

文档管理系统事件处理 ​

javascript
// 文档管理系统事件处理
class DocumentManagementSystem {
    constructor() {
        this.documentState = {
            isOpen: false,
            isModified: false,
            currentFile: null,
            lastOperation: null
        };
        this.initEventHandlers();
    }
    
    // 初始化事件处理器
    initEventHandlers() {
        // 文档相关事件
        this.OnDocumentOpened = this.handleDocumentOpened.bind(this);
        this.OnDocumentClosed = this.handleDocumentClosed.bind(this);
        this.AfterOpenFromURL = this.handleAfterOpenFromURL.bind(this);
        this.OnFileCommand = this.handleFileCommand.bind(this);
        this.OnPublishAsPDFToURL = this.handlePublishAsPDFToURL.bind(this);
        this.OnPublishAsOFDToURL = this.handlePublishAsOFDToURL.bind(this);
        
        // 菜单相关事件
        this.OnCustomMenuCmd2 = this.handleCustomMenuCmd2.bind(this);
        this.OnCustomFileMenuCmd = this.handleCustomFileMenuCmd.bind(this);
        this.BeforeOriginalMenuCommand = this.handleBeforeOriginalMenuCommand.bind(this);
        
        // 按钮相关事件
        this.OnCustomButtonOnMenuCmd = this.handleCustomButtonOnMenuCmd.bind(this);
        this.OnCustomToolBarCommand = this.handleCustomToolBarCommand.bind(this);
        
        // Word相关事件
        this.OnWordWPSSelChange = this.handleWordWPSSelChange.bind(this);
        this.OnWordBeforeRightClick = this.handleWordBeforeRightClick.bind(this);
        
        // Excel相关事件
        this.OnSheetSelectionChange = this.handleSheetSelectionChange.bind(this);
        this.OnSheetBeforeDoubleClick = this.handleSheetBeforeDoubleClick.bind(this);
        this.OnSheetBeforeRightClick = this.handleSheetBeforeRightClick.bind(this);
        this.OnSheetChange = this.handleSheetChange.bind(this);
    }
    
    // 处理文档打开
    handleDocumentOpened(doc, file) {
        console.log("文档已打开：", file);
        this.documentState.isOpen = true;
        this.documentState.currentFile = file;
        this.documentState.lastOperation = 'opened';
        
        // 更新UI状态
        this.updateUIState('documentOpened');
        
        // 加载文档配置
        this.loadDocumentConfig(file);
        
        // 初始化文档
        this.initializeDocument(doc);
    }
    
    // 处理文档关闭
    handleDocumentClosed() {
        console.log("文档已关闭");
        this.documentState.isOpen = false;
        this.documentState.currentFile = null;
        this.documentState.lastOperation = 'closed';
        
        // 更新UI状态
        this.updateUIState('documentClosed');
        
        // 保存用户设置
        this.saveUserSettings();
        
        // 清理资源
        this.cleanupResources();
    }
    
    // 处理从URL打开后
    handleAfterOpenFromURL(doc, statusCode) {
        console.log("从URL打开文档：", statusCode);
        if (statusCode === 0) {
            this.handleDocumentOpened(doc, "URL文档");
        } else {
            console.error("从URL打开文档失败：", statusCode);
            this.handleDocumentOpenError(statusCode);
        }
    }
    
    // 处理文件命令
    handleFileCommand(item, isCancel) {
        console.log("文件命令：", item, isCancel);
        switch(item) {
            case 1: // 新建
                this.handleNewDocument();
                break;
            case 2: // 打开
                this.handleOpenDocument();
                break;
            case 3: // 保存
                this.handleSaveDocument();
                break;
            case 4: // 另存为
                this.handleSaveAsDocument();
                break;
            case 5: // 打印
                this.handlePrintDocument();
                break;
            default:
                console.log("未知文件命令：", item);
        }
    }
    
    // 处理PDF发布
    handlePublishAsPDFToURL(retData, errorCode) {
        console.log("PDF发布：", retData, errorCode);
        if (errorCode === 0) {
            console.log("PDF发布成功");
            this.showSuccessMessage("PDF发布成功");
        } else {
            console.error("PDF发布失败：", errorCode);
            this.showErrorMessage("PDF发布失败");
        }
    }
    
    // 处理OFD发布
    handlePublishAsOFDToURL(retData, errorCode) {
        console.log("OFD发布：", retData, errorCode);
        if (errorCode === 0) {
            console.log("OFD发布成功");
            this.showSuccessMessage("OFD发布成功");
        } else {
            console.error("OFD发布失败：", errorCode);
            this.showErrorMessage("OFD发布失败");
        }
    }
    
    // 处理自定义菜单命令
    handleCustomMenuCmd2(menuPos, submenuPos, subsubmenuPos, menuCaption, myMenuID) {
        console.log("自定义菜单命令：", menuCaption, myMenuID);
        switch(myMenuID) {
            case 100:
                this.handleNewDocument();
                break;
            case 101:
                this.handleOpenDocument();
                break;
            case 102:
                this.handleSaveDocument();
                break;
            case 103:
                this.handlePrintDocument();
                break;
            default:
                console.log("未知自定义菜单命令：", myMenuID);
        }
    }
    
    // 处理自定义文件菜单命令
    handleCustomFileMenuCmd(menuIndex, menuCaption, menuID) {
        console.log("自定义文件菜单命令：", menuCaption, menuID);
        switch(menuID) {
            case 300:
                this.handleCustomSave();
                break;
            case 301:
                this.handleCustomExport();
                break;
            case 302:
                this.handleCustomImport();
                break;
            default:
                console.log("未知自定义文件菜单命令：", menuID);
        }
    }
    
    // 处理原始菜单命令前
    handleBeforeOriginalMenuCommand(menuTitle, isCancel) {
        console.log("原始菜单命令前：", menuTitle, isCancel);
        // 根据菜单标题决定是否取消操作
        if (this.shouldCancelOperation(menuTitle)) {
            isCancel = true;
            console.log("取消操作：", menuTitle);
        } else {
            isCancel = false;
            console.log("允许操作：", menuTitle);
        }
    }
    
    // 处理自定义菜单按钮命令
    handleCustomButtonOnMenuCmd(btnPos, btnCaption, btnID) {
        console.log("自定义菜单按钮命令：", btnCaption, btnID);
        switch(btnID) {
            case 400:
                this.handleQuickSave();
                break;
            case 401:
                this.handleQuickPrint();
                break;
            case 402:
                this.handleQuickExport();
                break;
            default:
                console.log("未知自定义菜单按钮命令：", btnID);
        }
    }
    
    // 处理自定义工具栏按钮命令
    handleCustomToolBarCommand(buttonIndex) {
        console.log("自定义工具栏按钮命令：", buttonIndex);
        switch(buttonIndex) {
            case 0:
                this.handleToolbarNew();
                break;
            case 1:
                this.handleToolbarOpen();
                break;
            case 2:
                this.handleToolbarSave();
                break;
            case 3:
                this.handleToolbarPrint();
                break;
            default:
                console.log("未知自定义工具栏按钮命令：", buttonIndex);
        }
    }
    
    // 处理Word选择变化
    handleWordWPSSelChange(selection) {
        console.log("Word选择变化：", selection);
        // 更新选择状态
        this.updateSelectionState(selection);
        
        // 更新工具栏状态
        this.updateToolbarState(selection);
    }
    
    // 处理Word右键
    handleWordBeforeRightClick(selection, isCancel) {
        console.log("Word右键：", selection, isCancel);
        // 检查是否应该显示自定义右键菜单
        if (this.shouldShowCustomContextMenu(selection)) {
            isCancel = true;
            this.showCustomContextMenu(selection);
        } else {
            isCancel = false;
        }
    }
    
    // 处理Excel选择变化
    handleSheetSelectionChange(sheetName, row, col) {
        console.log("Excel选择变化：", sheetName, row, col);
        // 更新选择状态
        this.updateSheetSelectionState(sheetName, row, col);
        
        // 更新工具栏状态
        this.updateSheetToolbarState(sheetName, row, col);
    }
    
    // 处理Excel双击
    handleSheetBeforeDoubleClick(sheetName, row, col, isCancel) {
        console.log("Excel双击：", sheetName, row, col, isCancel);
        // 检查是否应该取消默认操作
        if (this.shouldCancelSheetDoubleClick(sheetName, row, col)) {
            isCancel = true;
            this.handleCustomSheetDoubleClick(sheetName, row, col);
        } else {
            isCancel = false;
        }
    }
    
    // 处理Excel右键
    handleSheetBeforeRightClick(sheetName, row, col, isCancel) {
        console.log("Excel右键：", sheetName, row, col, isCancel);
        // 检查是否应该显示自定义右键菜单
        if (this.shouldShowCustomSheetContextMenu(sheetName, row, col)) {
            isCancel = true;
            this.showCustomSheetContextMenu(sheetName, row, col);
        } else {
            isCancel = false;
        }
    }
    
    // 处理Excel单元格变化
    handleSheetChange(sheetName, row, col) {
        console.log("Excel单元格变化：", sheetName, row, col);
        // 记录单元格变化
        this.recordCellChange(sheetName, row, col);
        
        // 验证单元格内容
        this.validateCellContent(sheetName, row, col);
        
        // 更新相关单元格
        this.updateRelatedCells(sheetName, row, col);
    }
    
    // 更新UI状态
    updateUIState(state) {
        console.log("更新UI状态：", state);
        // 实现UI状态更新逻辑
    }
    
    // 加载文档配置
    loadDocumentConfig(file) {
        console.log("加载文档配置：", file);
        // 实现文档配置加载逻辑
    }
    
    // 初始化文档
    initializeDocument(doc) {
        console.log("初始化文档：", doc);
        // 实现文档初始化逻辑
    }
    
    // 保存用户设置
    saveUserSettings() {
        console.log("保存用户设置");
        // 实现用户设置保存逻辑
    }
    
    // 清理资源
    cleanupResources() {
        console.log("清理资源");
        // 实现资源清理逻辑
    }
    
    // 显示成功消息
    showSuccessMessage(message) {
        console.log("成功消息：", message);
        // 实现成功消息显示逻辑
    }
    
    // 显示错误消息
    showErrorMessage(message) {
        console.error("错误消息：", message);
        // 实现错误消息显示逻辑
    }
    
    // 检查是否应该取消操作
    shouldCancelOperation(menuTitle) {
        // 根据菜单标题决定是否取消操作
        var restrictedOperations = ["删除", "清空", "重置"];
        return restrictedOperations.includes(menuTitle);
    }
    
    // 检查是否应该显示自定义右键菜单
    shouldShowCustomContextMenu(selection) {
        // 根据选择内容决定是否显示自定义右键菜单
        return selection && selection.Text && selection.Text.trim().length > 0;
    }
    
    // 显示自定义右键菜单
    showCustomContextMenu(selection) {
        console.log("显示自定义右键菜单");
        // 实现自定义右键菜单显示逻辑
    }
    
    // 检查是否应该取消Excel双击
    shouldCancelSheetDoubleClick(sheetName, row, col) {
        // 根据位置决定是否取消Excel双击
        return row <= 2 || col <= 2; // 假设前两行和前两列是保护的
    }
    
    // 处理自定义Excel双击
    handleCustomSheetDoubleClick(sheetName, row, col) {
        console.log("处理自定义Excel双击");
        // 实现自定义Excel双击处理逻辑
    }
    
    // 检查是否应该显示自定义Excel右键菜单
    shouldShowCustomSheetContextMenu(sheetName, row, col) {
        // 根据位置决定是否显示自定义Excel右键菜单
        return row <= 2 || col <= 2; // 假设前两行和前两列是保护的
    }
    
    // 显示自定义Excel右键菜单
    showCustomSheetContextMenu(sheetName, row, col) {
        console.log("显示自定义Excel右键菜单");
        // 实现自定义Excel右键菜单显示逻辑
    }
    
    // 记录单元格变化
    recordCellChange(sheetName, row, col) {
        console.log("记录单元格变化：", sheetName, row, col);
        // 实现单元格变化记录逻辑
    }
    
    // 验证单元格内容
    validateCellContent(sheetName, row, col) {
        console.log("验证单元格内容：", sheetName, row, col);
        // 实现单元格内容验证逻辑
    }
    
    // 更新相关单元格
    updateRelatedCells(sheetName, row, col) {
        console.log("更新相关单元格：", sheetName, row, col);
        // 实现相关单元格更新逻辑
    }
}

// 创建文档管理系统实例
const documentManagementSystem = new DocumentManagementSystem();

// 全局事件处理函数
function OnDocumentOpened(doc, file) {
    documentManagementSystem.OnDocumentOpened(doc, file);
}

function OnDocumentClosed() {
    documentManagementSystem.OnDocumentClosed();
}

function AfterOpenFromURL(doc, statusCode) {
    documentManagementSystem.AfterOpenFromURL(doc, statusCode);
}

function OnFileCommand(item, isCancel) {
    documentManagementSystem.OnFileCommand(item, isCancel);
}

function OnPublishAsPDFToURL(retData, errorCode) {
    documentManagementSystem.OnPublishAsPDFToURL(retData, errorCode);
}

function OnPublishAsOFDToURL(retData, errorCode) {
    documentManagementSystem.OnPublishAsOFDToURL(retData, errorCode);
}

function OnCustomMenuCmd2(menuPos, submenuPos, subsubmenuPos, menuCaption, myMenuID) {
    documentManagementSystem.OnCustomMenuCmd2(menuPos, submenuPos, subsubmenuPos, menuCaption, myMenuID);
}

function OnCustomFileMenuCmd(menuIndex, menuCaption, menuID) {
    documentManagementSystem.OnCustomFileMenuCmd(menuIndex, menuCaption, menuID);
}

function BeforeOriginalMenuCommand(menuTitle, isCancel) {
    documentManagementSystem.BeforeOriginalMenuCommand(menuTitle, isCancel);
}

function OnCustomButtonOnMenuCmd(btnPos, btnCaption, btnID) {
    documentManagementSystem.OnCustomButtonOnMenuCmd(btnPos, btnCaption, btnID);
}

function OnCustomToolBarCommand(buttonIndex) {
    documentManagementSystem.OnCustomToolBarCommand(buttonIndex);
}

function OnWordWPSSelChange(selection) {
    documentManagementSystem.OnWordWPSSelChange(selection);
}

function OnWordBeforeRightClick(selection, isCancel) {
    documentManagementSystem.OnWordBeforeRightClick(selection, isCancel);
}

function OnSheetSelectionChange(sheetName, row, col) {
    documentManagementSystem.OnSheetSelectionChange(sheetName, row, col);
}

function OnSheetBeforeDoubleClick(sheetName, row, col, isCancel) {
    documentManagementSystem.OnSheetBeforeDoubleClick(sheetName, row, col, isCancel);
}

function OnSheetBeforeRightClick(sheetName, row, col, isCancel) {
    documentManagementSystem.OnSheetBeforeRightClick(sheetName, row, col, isCancel);
}

function OnSheetChange(sheetName, row, col) {
    documentManagementSystem.OnSheetChange(sheetName, row, col);
}

注意事项 ​

  1. 事件绑定：

    • 确保在HTML中正确绑定事件处理函数
    • 事件函数名要与HTML中的属性值一致
    • 注意大小写和拼写

  2. 参数处理：

    • 检查参数的有效性
    • 处理可选参数的情况
    • 注意参数的数据类型

  3. 错误处理：

    • 使用try-catch包装事件处理逻辑
    • 处理事件处理中的异常
    • 提供用户友好的错误信息

  4. 性能优化：

    • 避免在事件处理中执行耗时操作
    • 合理使用异步操作
    • 避免重复处理

  5. 用户体验：

    • 提供及时的状态反馈
    • 显示操作进度
    • 处理用户交互

  6. 兼容性：

    • 考虑不同浏览器的兼容性
    • 处理不同版本的差异
    • 测试各种场景

  7. 调试和测试：

    • 记录事件处理日志
    • 测试各种事件场景
    • 验证事件功能完整性

  8. 维护性：

    • 使用模块化的事件处理
    • 保持事件处理函数的简洁
    • 定期重构和优化代码

Copyright © 2025 软航科技