软航科技文档中心

Appearance

EXCEL相关事件 ​

选择变化事件 ​

OnSheetSelectionChange ​

语法 ​

javascript
OnSheetSelectionChange(SheetName, row, col)

参数 ​

名称必选/可选数据类型说明
SheetName必选string工作表名称
row必选long表格行号
col必选long表格列号

说明 ​

该事件在EXCEL所选区域改变时发生。 第一个参数是sheet名称，第二个参数是新区域左上角单元格所在行，第三个参数是新区域左上角单元格所在列。

示例代码 ​

javascript
// Excel选择变化事件处理
function OnSheetSelectionChange(SheetName, row, col) {
    console.log("Excel选择变化事件触发");
    console.log("工作表名称：", SheetName);
    console.log("行号：", row);
    console.log("列号：", col);
    
    // 获取选择信息
    var selectionInfo = getSelectionInfo(SheetName, row, col);
    console.log("选择信息：", selectionInfo);
    
    // 处理选择变化
    handleSelectionChange(selectionInfo);
}

// 获取选择信息
function getSelectionInfo(sheetName, row, col) {
    try {
        var info = {
            sheetName: sheetName,
            row: row,
            col: col,
            cellAddress: getCellAddress(row, col),
            timestamp: new Date().toISOString()
        };
        return info;
    } catch (error) {
        console.error("获取选择信息失败：", error);
        return null;
    }
}

// 获取单元格地址
function getCellAddress(row, col) {
    var columnLetter = getColumnLetter(col);
    return columnLetter + row;
}

// 获取列字母
function getColumnLetter(col) {
    var result = '';
    while (col > 0) {
        col--;
        result = String.fromCharCode(65 + (col % 26)) + result;
        col = Math.floor(col / 26);
    }
    return result;
}

// 处理选择变化
function handleSelectionChange(selectionInfo) {
    if (selectionInfo) {
        console.log("当前选择：", selectionInfo.cellAddress);
        
        // 更新状态栏
        updateStatusBar(selectionInfo);
        
        // 更新工具栏状态
        updateToolbarState(selectionInfo);
        
        // 显示单元格信息
        showCellInfo(selectionInfo);
    }
}

// 更新状态栏
function updateStatusBar(selectionInfo) {
    var statusText = "当前选择：" + selectionInfo.cellAddress;
    updateStatusBarText(statusText);
}

// 更新工具栏状态
function updateToolbarState(selectionInfo) {
    // 启用编辑相关按钮
    enableEditButtons();
    
    // 根据选择位置启用相应功能
    if (isHeaderRow(selectionInfo.row)) {
        enableHeaderFunctions();
    }
    
    if (isDataRow(selectionInfo.row)) {
        enableDataFunctions();
    }
}

// 检查是否为标题行
function isHeaderRow(row) {
    return row === 1;
}

// 检查是否为数据行
function isDataRow(row) {
    return row > 1;
}

// 显示单元格信息
function showCellInfo(selectionInfo) {
    // 显示单元格详细信息
    console.log("单元格信息：", selectionInfo);
}

双击事件 ​

OnSheetBeforeDoubleClick ​

语法 ​

javascript
OnSheetBeforeDoubleClick(SheetName, row, col, IsCancel)

参数 ​

名称必选/可选数据类型说明
SheetName必选string工作表名称
row必选long表格行号
col必选long表格列号
IsCancel必选bool是否取消操作

说明 ​

该事件在EXCEL双击事件发生之前激活。 第一个参数是sheet名称，第二个参数是新区域左上角单元格所在行，第三个参数是新区域左上角单元格所在列。第4个参数是是否取消事件。在WEB编程中，第4个参数不能使用，而应该在此事件中，使用CancelSheetDoubleClick属性设置为true来取消事件。

示例代码 ​

javascript
// Excel双击事件处理
function OnSheetBeforeDoubleClick(SheetName, row, col, IsCancel) {
    console.log("Excel双击事件触发");
    console.log("工作表名称：", SheetName);
    console.log("行号：", row);
    console.log("列号：", col);
    
    // 获取双击位置信息
    var doubleClickInfo = getDoubleClickInfo(SheetName, row, col);
    console.log("双击信息：", doubleClickInfo);
    
    // 检查是否应该取消默认操作
    if (shouldCancelDefaultAction(doubleClickInfo)) {
        // 取消默认双击操作
        IsCancel = true;
        console.log("取消默认双击操作");
        
        // 执行自定义双击操作
        handleCustomDoubleClick(doubleClickInfo);
    } else {
        // 允许默认双击操作
        IsCancel = false;
        console.log("允许默认双击操作");
    }
}

// 获取双击位置信息
function getDoubleClickInfo(sheetName, row, col) {
    try {
        var info = {
            sheetName: sheetName,
            row: row,
            col: col,
            cellAddress: getCellAddress(row, col),
            cellValue: getCellValue(sheetName, row, col),
            cellType: getCellType(sheetName, row, col),
            timestamp: new Date().toISOString()
        };
        return info;
    } catch (error) {
        console.error("获取双击信息失败：", error);
        return null;
    }
}

// 获取单元格值
function getCellValue(sheetName, row, col) {
    try {
        var cellAddress = getCellAddress(row, col);
        return OCX_OBJ.GetRangeValue(sheetName, cellAddress);
    } catch (error) {
        console.error("获取单元格值失败：", error);
        return null;
    }
}

// 获取单元格类型
function getCellType(sheetName, row, col) {
    try {
        var cellAddress = getCellAddress(row, col);
        var formula = OCX_OBJ.GetRangeFormula(sheetName, cellAddress);
        if (formula && formula.startsWith("=")) {
            return "formula";
        } else {
            return "value";
        }
    } catch (error) {
        console.error("获取单元格类型失败：", error);
        return "unknown";
    }
}

// 检查是否应该取消默认操作
function shouldCancelDefaultAction(doubleClickInfo) {
    if (!doubleClickInfo) return false;
    
    // 根据单元格类型决定是否取消
    if (doubleClickInfo.cellType === "formula") {
        return true; // 公式单元格取消默认操作
    }
    
    // 根据单元格值决定
    if (isSpecialCell(doubleClickInfo.cellValue)) {
        return true; // 特殊单元格取消默认操作
    }
    
    // 根据位置决定
    if (isProtectedArea(doubleClickInfo.row, doubleClickInfo.col)) {
        return true; // 保护区域取消默认操作
    }
    
    return false;
}

// 检查是否为特殊单元格
function isSpecialCell(cellValue) {
    // 检查是否为特殊值（如链接、图片等）
    return cellValue && (cellValue.includes("http") || cellValue.includes("mailto"));
}

// 检查是否为保护区域
function isProtectedArea(row, col) {
    // 检查是否为保护的行或列
    return row <= 2 || col <= 2; // 假设前两行和前两列是保护的
}

// 处理自定义双击操作
function handleCustomDoubleClick(doubleClickInfo) {
    console.log("执行自定义双击操作");
    
    // 根据单元格类型执行不同操作
    switch (doubleClickInfo.cellType) {
        case "formula":
            handleFormulaDoubleClick(doubleClickInfo);
            break;
        case "value":
            handleValueDoubleClick(doubleClickInfo);
            break;
        default:
            handleDefaultDoubleClick(doubleClickInfo);
    }
}

// 处理公式单元格双击
function handleFormulaDoubleClick(doubleClickInfo) {
    console.log("处理公式单元格双击");
    // 显示公式编辑器
    showFormulaEditor(doubleClickInfo);
}

// 处理值单元格双击
function handleValueDoubleClick(doubleClickInfo) {
    console.log("处理值单元格双击");
    // 进入编辑模式
    enterEditMode(doubleClickInfo);
}

// 处理默认双击
function handleDefaultDoubleClick(doubleClickInfo) {
    console.log("处理默认双击");
    // 执行默认操作
    executeDefaultAction(doubleClickInfo);
}

// 显示公式编辑器
function showFormulaEditor(doubleClickInfo) {
    console.log("显示公式编辑器");
    // 实现公式编辑器逻辑
}

// 进入编辑模式
function enterEditMode(doubleClickInfo) {
    console.log("进入编辑模式");
    // 实现编辑模式逻辑
}

// 执行默认操作
function executeDefaultAction(doubleClickInfo) {
    console.log("执行默认操作");
    // 实现默认操作逻辑
}

右键事件 ​

OnSheetBeforeRightClick ​

语法 ​

javascript
OnSheetBeforeRightClick(SheetName, row, col, IsCancel)

参数 ​

名称必选/可选数据类型说明
SheetName必选string工作表名称
row必选long表格行号
col必选long表格列号
IsCancel必选bool是否取消操作

说明 ​

该事件在EXCEL右键事件发生之前激活。 第一个参数是sheet名称，第二个参数是新区域左上角单元格所在行，第三个参数是新区域左上角单元格所在列。第4个参数是是否取消事件。在WEB编程中，第4个参数不能使用，而应该在此事件中，使用CancelSheetRightClick属性设置为true来取消事件。

示例代码 ​

javascript
// Excel右键事件处理
function OnSheetBeforeRightClick(SheetName, row, col, IsCancel) {
    console.log("Excel右键事件触发");
    console.log("工作表名称：", SheetName);
    console.log("行号：", row);
    console.log("列号：", col);
    
    // 获取右键位置信息
    var rightClickInfo = getRightClickInfo(SheetName, row, col);
    console.log("右键信息：", rightClickInfo);
    
    // 检查是否应该显示自定义右键菜单
    if (shouldShowCustomContextMenu(rightClickInfo)) {
        // 取消默认右键菜单
        IsCancel = true;
        console.log("取消默认右键菜单");
        
        // 显示自定义右键菜单
        showCustomContextMenu(rightClickInfo);
    } else {
        // 允许默认右键菜单
        IsCancel = false;
        console.log("允许默认右键菜单");
    }
}

// 获取右键位置信息
function getRightClickInfo(sheetName, row, col) {
    try {
        var info = {
            sheetName: sheetName,
            row: row,
            col: col,
            cellAddress: getCellAddress(row, col),
            cellValue: getCellValue(sheetName, row, col),
            cellType: getCellType(sheetName, row, col),
            isSelected: isCellSelected(sheetName, row, col),
            timestamp: new Date().toISOString()
        };
        return info;
    } catch (error) {
        console.error("获取右键信息失败：", error);
        return null;
    }
}

// 检查单元格是否被选中
function isCellSelected(sheetName, row, col) {
    try {
        var cellAddress = getCellAddress(row, col);
        var selection = OCX_OBJ.GetRangeValue(sheetName, cellAddress);
        return selection !== null;
    } catch (error) {
        console.error("检查单元格选中状态失败：", error);
        return false;
    }
}

// 检查是否应该显示自定义右键菜单
function shouldShowCustomContextMenu(rightClickInfo) {
    if (!rightClickInfo) return false;
    
    // 根据单元格类型决定
    if (rightClickInfo.cellType === "formula") {
        return true; // 公式单元格显示自定义菜单
    }
    
    // 根据单元格值决定
    if (isSpecialCell(rightClickInfo.cellValue)) {
        return true; // 特殊单元格显示自定义菜单
    }
    
    // 根据位置决定
    if (isHeaderRow(rightClickInfo.row) || isHeaderCol(rightClickInfo.col)) {
        return true; // 标题行或列显示自定义菜单
    }
    
    return false;
}

// 检查是否为标题列
function isHeaderCol(col) {
    return col === 1;
}

// 显示自定义右键菜单
function showCustomContextMenu(rightClickInfo) {
    console.log("显示自定义右键菜单");
    
    // 创建自定义右键菜单
    var contextMenu = createContextMenu(rightClickInfo);
    
    // 显示菜单
    showContextMenu(contextMenu);
}

// 创建自定义右键菜单
function createContextMenu(rightClickInfo) {
    var menuItems = [];
    
    if (rightClickInfo.cellType === "formula") {
        // 公式单元格菜单
        menuItems.push({
            text: "编辑公式",
            action: function() { editFormula(rightClickInfo); }
        });
        menuItems.push({
            text: "复制公式",
            action: function() { copyFormula(rightClickInfo); }
        });
        menuItems.push({
            text: "删除公式",
            action: function() { deleteFormula(rightClickInfo); }
        });
    } else {
        // 普通单元格菜单
        menuItems.push({
            text: "复制",
            action: function() { copyCell(rightClickInfo); }
        });
        menuItems.push({
            text: "剪切",
            action: function() { cutCell(rightClickInfo); }
        });
        menuItems.push({
            text: "粘贴",
            action: function() { pasteCell(rightClickInfo); }
        });
        menuItems.push({
            text: "删除",
            action: function() { deleteCell(rightClickInfo); }
        });
    }
    
    // 添加通用菜单项
    menuItems.push({
        text: "插入行",
        action: function() { insertRow(rightClickInfo); }
    });
    menuItems.push({
        text: "插入列",
        action: function() { insertColumn(rightClickInfo); }
    });
    menuItems.push({
        text: "删除行",
        action: function() { deleteRow(rightClickInfo); }
    });
    menuItems.push({
        text: "删除列",
        action: function() { deleteColumn(rightClickInfo); }
    });
    
    return menuItems;
}

// 显示右键菜单
function showContextMenu(menuItems) {
    // 创建菜单元素
    var menu = document.createElement('div');
    menu.className = 'custom-context-menu';
    
    // 添加菜单项
    menuItems.forEach(function(item) {
        var menuItem = document.createElement('div');
        menuItem.className = 'context-menu-item';
        menuItem.textContent = item.text;
        menuItem.onclick = item.action;
        menu.appendChild(menuItem);
    });
    
    // 添加到页面
    document.body.appendChild(menu);
    
    // 设置菜单位置
    positionContextMenu(menu);
    
    // 点击其他地方隐藏菜单
    document.addEventListener('click', function() {
        document.body.removeChild(menu);
    });
}

// 设置菜单位置
function positionContextMenu(menu) {
    // 获取鼠标位置
    var mouseX = event.clientX;
    var mouseY = event.clientY;
    
    // 设置菜单位置
    menu.style.position = 'absolute';
    menu.style.left = mouseX + 'px';
    menu.style.top = mouseY + 'px';
    menu.style.zIndex = '9999';
}

// 菜单项操作函数
function editFormula(rightClickInfo) {
    console.log("编辑公式：", rightClickInfo.cellAddress);
    // 实现编辑公式逻辑
}

function copyFormula(rightClickInfo) {
    console.log("复制公式：", rightClickInfo.cellAddress);
    // 实现复制公式逻辑
}

function deleteFormula(rightClickInfo) {
    console.log("删除公式：", rightClickInfo.cellAddress);
    // 实现删除公式逻辑
}

function copyCell(rightClickInfo) {
    console.log("复制单元格：", rightClickInfo.cellAddress);
    // 实现复制单元格逻辑
}

function cutCell(rightClickInfo) {
    console.log("剪切单元格：", rightClickInfo.cellAddress);
    // 实现剪切单元格逻辑
}

function pasteCell(rightClickInfo) {
    console.log("粘贴单元格：", rightClickInfo.cellAddress);
    // 实现粘贴单元格逻辑
}

function deleteCell(rightClickInfo) {
    console.log("删除单元格：", rightClickInfo.cellAddress);
    // 实现删除单元格逻辑
}

function insertRow(rightClickInfo) {
    console.log("插入行：", rightClickInfo.row);
    // 实现插入行逻辑
}

function insertColumn(rightClickInfo) {
    console.log("插入列：", rightClickInfo.col);
    // 实现插入列逻辑
}

function deleteRow(rightClickInfo) {
    console.log("删除行：", rightClickInfo.row);
    // 实现删除行逻辑
}

function deleteColumn(rightClickInfo) {
    console.log("删除列：", rightClickInfo.col);
    // 实现删除列逻辑
}

单元格变化事件 ​

OnSheetChange ​

语法 ​

javascript
OnSheetChange(SheetName, row, col)

参数 ​

名称必选/可选数据类型说明
SheetName必选string工作表名称
row必选long表格行号
col必选long表格列号

说明 ​

该事件在Excel单元格被改变时触发。 第一个参数是sheet名称，第二个参数是新区域左上角单元格所在行，第三个参数是新区域左上角单元格所在列。

示例代码 ​

javascript
// Excel单元格变化事件处理
function OnSheetChange(SheetName, row, col) {
    console.log("Excel单元格变化事件触发");
    console.log("工作表名称：", SheetName);
    console.log("行号：", row);
    console.log("列号：", col);
    
    // 获取变化信息
    var changeInfo = getChangeInfo(SheetName, row, col);
    console.log("变化信息：", changeInfo);
    
    // 处理单元格变化
    handleCellChange(changeInfo);
}

// 获取变化信息
function getChangeInfo(sheetName, row, col) {
    try {
        var info = {
            sheetName: sheetName,
            row: row,
            col: col,
            cellAddress: getCellAddress(row, col),
            cellValue: getCellValue(sheetName, row, col),
            cellType: getCellType(sheetName, row, col),
            timestamp: new Date().toISOString()
        };
        return info;
    } catch (error) {
        console.error("获取变化信息失败：", error);
        return null;
    }
}

// 处理单元格变化
function handleCellChange(changeInfo) {
    if (changeInfo) {
        console.log("单元格变化：", changeInfo.cellAddress);
        
        // 记录变化历史
        recordChangeHistory(changeInfo);
        
        // 验证单元格内容
        validateCellContent(changeInfo);
        
        // 更新相关单元格
        updateRelatedCells(changeInfo);
        
        // 触发自动计算
        triggerAutoCalculation(changeInfo);
    }
}

// 记录变化历史
function recordChangeHistory(changeInfo) {
    try {
        var history = {
            cellAddress: changeInfo.cellAddress,
            oldValue: getOldValue(changeInfo),
            newValue: changeInfo.cellValue,
            timestamp: changeInfo.timestamp,
            user: getCurrentUser()
        };
        
        // 保存到历史记录
        saveChangeHistory(history);
        console.log("变化历史已记录：", history);
    } catch (error) {
        console.error("记录变化历史失败：", error);
    }
}

// 获取旧值
function getOldValue(changeInfo) {
    // 从历史记录中获取旧值
    // 这里需要实现获取旧值的逻辑
    return null;
}

// 验证单元格内容
function validateCellContent(changeInfo) {
    try {
        var validationRules = getValidationRules(changeInfo);
        
        for (var i = 0; i < validationRules.length; i++) {
            var rule = validationRules[i];
            if (!rule.validate(changeInfo.cellValue)) {
                console.warn("单元格内容验证失败：", changeInfo.cellAddress, rule.message);
                showValidationError(changeInfo, rule.message);
                return false;
            }
        }
        
        console.log("单元格内容验证通过：", changeInfo.cellAddress);
        return true;
    } catch (error) {
        console.error("验证单元格内容失败：", error);
        return false;
    }
}

// 获取验证规则
function getValidationRules(changeInfo) {
    var rules = [];
    
    // 根据列位置设置验证规则
    if (changeInfo.col === 1) {
        // 第一列：姓名验证
        rules.push({
            validate: function(value) { return value && value.trim().length > 0; },
            message: "姓名不能为空"
        });
    } else if (changeInfo.col === 2) {
        // 第二列：年龄验证
        rules.push({
            validate: function(value) { return !isNaN(value) && value > 0 && value < 150; },
            message: "年龄必须是1-149之间的数字"
        });
    } else if (changeInfo.col === 3) {
        // 第三列：邮箱验证
        rules.push({
            validate: function(value) { return isValidEmail(value); },
            message: "邮箱格式不正确"
        });
    }
    
    return rules;
}

// 检查邮箱格式
function isValidEmail(email) {
    var emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
}

// 显示验证错误
function showValidationError(changeInfo, message) {
    console.error("验证错误：", changeInfo.cellAddress, message);
    // 显示错误提示
    showErrorMessage("单元格 " + changeInfo.cellAddress + " 验证失败：" + message);
}

// 更新相关单元格
function updateRelatedCells(changeInfo) {
    try {
        // 检查是否有依赖的公式
        var dependentCells = getDependentCells(changeInfo);
        
        for (var i = 0; i < dependentCells.length; i++) {
            var cell = dependentCells[i];
            updateDependentCell(cell, changeInfo);
        }
        
        console.log("相关单元格已更新");
    } catch (error) {
        console.error("更新相关单元格失败：", error);
    }
}

// 获取依赖单元格
function getDependentCells(changeInfo) {
    // 这里需要实现获取依赖单元格的逻辑
    // 可以通过分析公式来找到依赖关系
    return [];
}

// 更新依赖单元格
function updateDependentCell(cell, changeInfo) {
    console.log("更新依赖单元格：", cell.address);
    // 实现更新依赖单元格的逻辑
}

// 触发自动计算
function triggerAutoCalculation(changeInfo) {
    try {
        // 检查是否需要重新计算
        if (needsRecalculation(changeInfo)) {
            console.log("触发自动计算");
            // 执行自动计算
            performAutoCalculation(changeInfo);
        }
    } catch (error) {
        console.error("触发自动计算失败：", error);
    }
}

// 检查是否需要重新计算
function needsRecalculation(changeInfo) {
    // 检查是否有公式依赖此单元格
    return hasFormulaDependencies(changeInfo);
}

// 检查是否有公式依赖
function hasFormulaDependencies(changeInfo) {
    // 这里需要实现检查公式依赖的逻辑
    return false;
}

// 执行自动计算
function performAutoCalculation(changeInfo) {
    console.log("执行自动计算");
    // 实现自动计算逻辑
}

完整示例 ​

Excel事件管理器 ​

javascript
// Excel事件管理器
class ExcelEventManager {
    constructor() {
        this.selectionHistory = [];
        this.changeHistory = [];
        this.contextMenuHandlers = new Map();
        this.changeHandlers = [];
    }
    
    // 注册选择变化处理器
    registerSelectionChangeHandler(handler) {
        this.selectionChangeHandlers.push(handler);
    }
    
    // 注册单元格变化处理器
    registerChangeHandler(handler) {
        this.changeHandlers.push(handler);
    }
    
    // 注册右键菜单处理器
    registerContextMenuHandler(condition, handler) {
        this.contextMenuHandlers.set(condition, handler);
    }
    
    // 处理选择变化
    handleSelectionChange(sheetName, row, col) {
        console.log("处理选择变化");
        
        var selectionInfo = {
            sheetName: sheetName,
            row: row,
            col: col,
            cellAddress: getCellAddress(row, col),
            timestamp: new Date().toISOString()
        };
        
        // 记录选择历史
        this.recordSelectionHistory(selectionInfo);
        
        // 通知所有处理器
        this.selectionChangeHandlers.forEach(handler => {
            try {
                handler(selectionInfo);
            } catch (error) {
                console.error("选择变化处理器错误：", error);
            }
        });
    }
    
    // 处理单元格变化
    handleCellChange(sheetName, row, col) {
        console.log("处理单元格变化");
        
        var changeInfo = {
            sheetName: sheetName,
            row: row,
            col: col,
            cellAddress: getCellAddress(row, col),
            cellValue: getCellValue(sheetName, row, col),
            timestamp: new Date().toISOString()
        };
        
        // 记录变化历史
        this.recordChangeHistory(changeInfo);
        
        // 通知所有处理器
        this.changeHandlers.forEach(handler => {
            try {
                handler(changeInfo);
            } catch (error) {
                console.error("单元格变化处理器错误：", error);
            }
        });
    }
    
    // 处理右键事件
    handleRightClick(sheetName, row, col, isCancel) {
        console.log("处理右键事件");
        
        var rightClickInfo = {
            sheetName: sheetName,
            row: row,
            col: col,
            cellAddress: getCellAddress(row, col),
            cellValue: getCellValue(sheetName, row, col)
        };
        
        // 检查是否需要自定义右键菜单
        var shouldShowCustom = this.shouldShowCustomContextMenu(rightClickInfo);
        
        if (shouldShowCustom) {
            isCancel = true;
            this.showCustomContextMenu(rightClickInfo);
        } else {
            isCancel = false;
        }
    }
    
    // 记录选择历史
    recordSelectionHistory(selectionInfo) {
        this.selectionHistory.push(selectionInfo);
        
        // 限制历史记录数量
        if (this.selectionHistory.length > 100) {
            this.selectionHistory.shift();
        }
    }
    
    // 记录变化历史
    recordChangeHistory(changeInfo) {
        this.changeHistory.push(changeInfo);
        
        // 限制历史记录数量
        if (this.changeHistory.length > 100) {
            this.changeHistory.shift();
        }
    }
    
    // 检查是否应该显示自定义右键菜单
    shouldShowCustomContextMenu(rightClickInfo) {
        for (var [condition, handler] of this.contextMenuHandlers) {
            if (condition(rightClickInfo)) {
                return true;
            }
        }
        return false;
    }
    
    // 显示自定义右键菜单
    showCustomContextMenu(rightClickInfo) {
        console.log("显示自定义右键菜单");
        // 实现自定义右键菜单逻辑
    }
}

// 创建Excel事件管理器实例
const excelEventManager = new ExcelEventManager();

// 注册事件处理器
excelEventManager.registerSelectionChangeHandler(function(selectionInfo) {
    console.log("选择变化：", selectionInfo.cellAddress);
});

excelEventManager.registerChangeHandler(function(changeInfo) {
    console.log("单元格变化：", changeInfo.cellAddress);
});

// 全局事件处理函数
function OnSheetSelectionChange(SheetName, row, col) {
    excelEventManager.handleSelectionChange(SheetName, row, col);
}

function OnSheetChange(SheetName, row, col) {
    excelEventManager.handleCellChange(SheetName, row, col);
}

function OnSheetBeforeRightClick(SheetName, row, col, IsCancel) {
    excelEventManager.handleRightClick(SheetName, row, col, IsCancel);
}

注意事项 ​

  1. 事件绑定：

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

  2. 参数处理：

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

  3. 单元格操作：

    • 安全地访问单元格数据
    • 处理访问失败的情况
    • 注意单元格地址格式

  4. 右键菜单：

    • 合理控制自定义右键菜单的显示
    • 处理菜单项点击事件
    • 注意菜单的定位和样式

  5. 性能优化：

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

  6. 错误处理：

    • 处理事件处理中的异常
    • 提供用户友好的错误信息
    • 记录错误日志

  7. 用户体验：

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

  8. 兼容性：

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

Copyright © 2025 软航科技