办公软件WPS的JSA中列出窗口菜单

cutebe

办公软件WPS的表格：通过ExecuteExcel4Macro调用WinAPI实现


列举记事本所有菜单文本：（请先打开一个记事本！）

1. function 显示窗口所有菜单测试(){        //记事本窗口
   
2.         console.clear();
   
3.         let 记事本句柄=查找窗口(0,"Notepad");        //按记事本类查找
   
4.         if(!记事本句柄){alert("未找到记事本！退出");return;}
   
5.         显示菜单(记事本句柄);
   
6. }

复制代码

打开记事本的字体对话框，相单于点击了菜单“格式》字体”：

1. function 查找窗口菜单并操作测试(){        //找一个记事本窗口，（模拟菜单）打开字体对话框
   
2.         console.clear();
   
3.         let 记事本句柄=查找窗口(0,"Notepad");        //按记事本类查找
   
4.         if(!记事本句柄){alert("未找到记事本！退出");return;}
   
5.        
   
6.         let 菜单组=查找菜单(记事本句柄,"字体");
   
7.         console.log("菜单组："+菜单组);
   
8.         if(菜单组.length==1){
   
9.                 console.log("只找到一个："+菜单组[0]);
   
10.                 let 执行命令=0x111;
    
11.                 投送带参消息(记事本句柄,执行命令,菜单组[0][1],0);        //相当于点击字体菜单项，打开字体对话框
    
12.         }
    
13. }

复制代码

用到的函数：

1. function 发送带参消息(窗口句柄,消息,短参,长参){        //短参16位，长参32位
   
2.         const 执行宏调用=ExecuteExcel4Macro;
   
3.         执行宏调用(`CALL("User32","SendMessageA","JJJJJ",${窗口句柄},${消息},${短参},${长参})`);
   
4. }
   
5. 
   
6. function 投送带参消息(窗口句柄,消息,短参,长参){        //短参16位，长参32位
   
7.         const 执行宏调用=ExecuteExcel4Macro;
   
8.         执行宏调用(`CALL("User32","PostMessageA","JJJJJ",${窗口句柄},${消息},${短参},${长参})`);
   
9. }
   
10. 
    
11. function 查找窗口(标题,类){        //返回句柄
    
12.         const 执行宏调用=ExecuteExcel4Macro;
    
13.         var 窗口句柄;
    
14.         if(!标题){        //标题为0               
    
15.                 if(!类){        窗口句柄=执行宏调用(`CALL("User32","FindWindowA","JJJ",0,0)`);        //类为0
    
16.                 }else{        窗口句柄=执行宏调用(`CALL("User32","FindWindowA","JFJ","${类}",0)`);}
    
17.         }else{
    
18.                 if(!类){        窗口句柄=执行宏调用(`CALL("User32","FindWindowA","JJF",0,"${标题}")`);        //类为0
    
19.                 }else{        窗口句柄=执行宏调用(`CALL("User32","FindWindowA","JFF","${类}","${标题}")`);}
    
20.         }
    
21.         return 窗口句柄;
    
22. }
    
23. 
    
24. function 显示菜单(窗口句柄){        //显示窗口主菜单文本
    
25.         let 菜单句柄=获取菜单(窗口句柄);
    
26.         let 菜单数=获取菜单数(菜单句柄);
    
27.         let 菜单标识=0x400;
    
28.         for(let i=0;i<菜单数;i++){        //菜单序号i
    
29.                 let 菜单文本=获取菜单文本(菜单句柄,i,菜单标识);
    
30.                 let 菜单号=获取菜单号(菜单句柄,i);
    
31.                 if(菜单号==-1){
    
32.                         console.log("菜单文本（+）："+菜单文本);
    
33.                         显示子菜单(菜单句柄,i);
    
34.                 }else{console.log("菜单文本（-）："+菜单文本+"\t菜单号："+菜单号);}
    
35.         }
    
36. }
    
37. 
    
38. function 显示子菜单(菜单句柄,菜单序号){        //显示子菜单文本（菜单号为0的一般为分隔线）
    
39.         let 子菜单句柄=获取子菜单(菜单句柄,菜单序号);
    
40.         let 子菜单数=获取菜单数(子菜单句柄);
    
41.         let 子菜单标识=0x400;
    
42.         for(let i=0;i<子菜单数;i++){        //子菜单序号i
    
43.                 let 子菜单文本=获取菜单文本(子菜单句柄,i,子菜单标识);
    
44.                 let 子菜单号=获取菜单号(子菜单句柄,i);
    
45.                 if(子菜单号==-1){
    
46.                         console.log("子菜单文本（+）："+子菜单文本);
    
47.                         显示子菜单(子菜单句柄,i);        //分隔线的菜单号为0
    
48.                 }else{console.log("子菜单文本（-）："+子菜单文本+"\t子菜单号："+子菜单号);}
    
49.         }
    
50. }
    
51. 
    
52. function 查找菜单(窗口句柄,部分菜单文本){
    
53.         let 菜单句柄=获取菜单(窗口句柄);
    
54.         let 菜单数=获取菜单数(菜单句柄);
    
55.         let 菜单标识=0x400;var 菜单组=[];
    
56.         for(let i=0;i<菜单数;i++){        //菜单序号i
    
57.                 let 菜单文本=获取菜单文本(菜单句柄,i,菜单标识);
    
58.                 let 菜单号=获取菜单号(菜单句柄,i);
    
59.                 if(菜单号==-1){
    
60.                         查找子菜单(菜单句柄,i,部分菜单文本,菜单组);
    
61.                 }else{
    
62.                         if(菜单文本.indexOf(部分菜单文本)!=-1){
    
63.                                 菜单组.push([菜单文本,菜单号]);
    
64.                         }
    
65.                 }
    
66.         }
    
67.         return 菜单组;
    
68. }
    
69. 
    
70. function 查找子菜单(菜单句柄,菜单序号,查找内容,菜单组){
    
71.         let 子菜单句柄=获取子菜单(菜单句柄,菜单序号);
    
72.         let 子菜单数=获取菜单数(子菜单句柄);
    
73.         let 子菜单标识=0x400;
    
74.         for(let i=0;i<子菜单数;i++){        //子菜单序号i
    
75.                 let 子菜单文本=获取菜单文本(子菜单句柄,i,子菜单标识);
    
76.                 let 子菜单号=获取菜单号(子菜单句柄,i);
    
77.                 if(子菜单号==-1){
    
78.                         查找子菜单(子菜单句柄,i,查找内容,菜单组);        //分隔线的菜单号为0
    
79.                 }else{
    
80.                         if(子菜单文本.indexOf(查找内容)!=-1){
    
81.                                 菜单组.push([子菜单文本,子菜单号]);
    
82.                         }
    
83.                 }
    
84.         }
    
85. }
    
86. 
    
87. function 获取菜单(窗口句柄){        //标准窗口的菜单对象句柄
    
88.         const 执行宏调用=ExecuteExcel4Macro;
    
89.         let 菜单句柄=执行宏调用(`CALL("User32","GetMenu","JJ",${窗口句柄})`);
    
90.         return 菜单句柄;
    
91. }
    
92. 
    
93. function 获取菜单数(菜单句柄){
    
94.         const 执行宏调用=ExecuteExcel4Macro;
    
95.         let 菜单数=执行宏调用(`CALL("User32","GetMenuItemCount","JJ",${菜单句柄})`);
    
96.         return 菜单数;
    
97. }
    
98. 
    
99. function 获取菜单号(菜单句柄,菜单序号){
    
100.         const 执行宏调用=ExecuteExcel4Macro;
     
101.         let 菜单号=执行宏调用(`CALL("User32","GetMenuItemID","JJJ",${菜单句柄},${菜单序号})`);
     
102.         return 菜单号;        //返回-1表示有子菜单
     
103. }
     
104. 
     
105. function 获取子菜单(菜单句柄,菜单序号){
     
106.         const 执行宏调用=ExecuteExcel4Macro;
     
107.         let 子菜单句柄=执行宏调用(`CALL("User32","GetSubMenu","JJJ",${菜单句柄},${菜单序号})`);
     
108.         return 子菜单句柄;
     
109. }
     
110. 
     
111. function 获取菜单文本(菜单句柄,菜单序号,菜单标识){
     
112.         const 执行宏调用=ExecuteExcel4Macro;
     
113.         let 菜单文本长度=执行宏调用(`CALL("User32","GetMenuStringA","JJJFJJ",${菜单句柄},${菜单序号},"",0,${菜单标识})`);
     
114.         let 内存地址=申请虚拟内存(菜单文本长度+1);
     
115.         执行宏调用(`CALL("User32","GetMenuStringA","JJJJJJ",${菜单句柄},${菜单序号},${内存地址},${菜单文本长度+1},${菜单标识})`);
     
116.         let 菜单文本=内存读取字符串(内存地址);
     
117.         释放虚拟内存(内存地址);
     
118.         return 菜单文本;
     
119. }
     
120. 
     
121. function 申请虚拟内存(字节数){        //返回内存地址
     
122.         const 执行宏调用=ExecuteExcel4Macro;
     
123.         const 内存地址=执行宏调用(`CALL("Kernel32","VirtualAlloc","JJJJJ",0,${字节数},${0x3000},4)`);
     
124.         return 内存地址;
     
125. }
     
126. 
     
127. function 释放虚拟内存(内存地址){
     
128.         const 执行宏调用=ExecuteExcel4Macro;
     
129.         执行宏调用(`CALL("Kernel32","VirtualFree","JJJJ",${内存地址},0,${0x8000})`);
     
130. }
     
131. 
     
132. function 内存读取字符串(内存地址){        //返回字符串
     
133.         const 执行宏调用=ExecuteExcel4Macro,段长度=127;
     
134.         const 总字节=执行宏调用(`CALL("Kernel32","lstrlenA","JJ",${内存地址})`);        //内存文本字节数
     
135.         let 偏移字节=0,文本字符串=分段文本='';
     
136.         while(偏移字节<总字节){        //返回字符串F。        //返回超255字节时，也需要分段操作
     
137.                 分段文本=执行宏调用(`CALL("Kernel32","lstrcpynW","FFJJ","",${内存地址+偏移字节},${段长度})`);
     
138.                 偏移字节+=分段文本.replace(/[^\x00-\xff]/g,'xx').length;        //计算字符串字节数
     
139.                 文本字符串+=分段文本;
     
140.         }
     
141.         return 文本字符串;
     
142. }
     

复制代码

y9032

收下了,这个很强大感谢楼主分享

小叶有梦

收下了,这个很强大感谢楼主分享

Blacksky

感谢分享辛苦了