wangzhibo
2026-07-16 b57020623cf0c946706573bf102e548c3a544423
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import { isEmpty, isFunction } from "lodash-es";
import { useCore } from "../../../hooks";
import { ContextMenu } from "../../context-menu";
 
// 单元行事件
export function useRow({
    Table,
    config,
    Sort
}: {
    Table: Vue.Ref<any>;
    config: ClTable.Config;
    Sort: {
        defaultSort: {
            prop?: string;
            order?: string;
        };
        changeSort(prop: string, order: string): void;
    };
}) {
    const { crud } = useCore();
 
    // 右键菜单
    function onRowContextMenu(row: obj, column: obj, event: PointerEvent) {
        // 菜单按钮
        const buttons = config.contextMenu;
        // 是否开启
        const enable = !isEmpty(buttons);
 
        if (enable) {
            // 高亮
            Table.value.setCurrentRow(row);
 
            // 解析按钮
            const list = buttons
                .map((e) => {
                    switch (e) {
                        case "refresh":
                            return {
                                label: crud.dict.label.refresh,
                                callback(done: fn) {
                                    crud.refresh();
                                    done();
                                }
                            };
                        case "edit":
                        case "update":
                            return {
                                label: crud.dict.label.update,
                                hidden: !crud.getPermission("update"),
                                callback(done: fn) {
                                    crud.rowEdit(row);
                                    done();
                                }
                            };
                        case "delete":
                            return {
                                label: crud.dict.label.delete,
                                hidden: !crud.getPermission("delete"),
                                callback(done: fn) {
                                    crud.rowDelete(row);
                                    done();
                                }
                            };
                        case "info":
                            return {
                                label: crud.dict.label.info,
                                hidden: !crud.getPermission("info"),
                                callback(done: fn) {
                                    crud.rowInfo(row);
                                    done();
                                }
                            };
                        case "check":
                            return {
                                label: crud.selection.find((e) => e.id == row.id)
                                    ? crud.dict.label.deselect
                                    : crud.dict.label.select,
                                hidden: !config.columns.find((e) => e.type === "selection"),
                                callback(done: fn) {
                                    Table.value.toggleRowSelection(row);
                                    done();
                                }
                            };
                        case "order-desc":
                            return {
                                label: `${column.label} - ${crud.dict.label.desc}`,
                                hidden: !column.sortable,
                                callback(done: fn) {
                                    Sort.changeSort(column.property, "desc");
                                    done();
                                }
                            };
                        case "order-asc":
                            return {
                                label: `${column.label} - ${crud.dict.label.asc}`,
                                hidden: !column.sortable,
                                callback(done: fn) {
                                    Sort.changeSort(column.property, "asc");
                                    done();
                                }
                            };
                        default:
                            if (isFunction(e)) {
                                return e(row, column, event);
                            } else {
                                return e;
                            }
                    }
                })
                .filter((e) => Boolean(e) && !e.hidden);
 
            // 打开菜单
            if (!isEmpty(list)) {
                ContextMenu.open(event, {
                    list
                });
            }
        }
 
        // 回调
        if (config.onRowContextmenu) {
            config.onRowContextmenu(row, column, event);
        }
    }
 
    return {
        onRowContextMenu
    };
}