1e20a83996d1687c811ee0eb4194d4560d016de9
[reactos.git] / reactos / subsystems / win32 / win32k / ntuser / accelerator.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: Window accelerator
5 * FILE: subsystems/win32/win32k/ntuser/accelerator.c
6 * PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Copyright 1993 Martin Ayotte
8 * Copyright 1994 Alexandre Julliard
9 * Copyright 1997 Morten Welinder
10 * Copyright 2011 Rafal Harabien
11 */
12
13 #include <win32k.h>
14 DBG_DEFAULT_CHANNEL(UserAccel);
15
16 #define FVIRT_TBL_END 0x80
17 #define FVIRT_MASK 0x7F
18
19 /* FUNCTIONS *****************************************************************/
20
21 PACCELERATOR_TABLE FASTCALL UserGetAccelObject(HACCEL hAccel)
22 {
23 PACCELERATOR_TABLE Accel;
24
25 if (!hAccel)
26 {
27 EngSetLastError(ERROR_INVALID_ACCEL_HANDLE);
28 return NULL;
29 }
30
31 Accel= UserGetObject(gHandleTable, hAccel, otAccel);
32 if (!Accel)
33 {
34 EngSetLastError(ERROR_INVALID_ACCEL_HANDLE);
35 return NULL;
36 }
37
38 return Accel;
39 }
40
41
42 static
43 BOOLEAN FASTCALL
44 co_IntTranslateAccelerator(
45 PWND Window,
46 CONST MSG *pMsg,
47 CONST ACCEL *pAccel)
48 {
49 BOOL bFound = FALSE;
50 UINT Mask = 0, nPos;
51 HWND hWnd;
52 HMENU hMenu, hSubMenu;
53 PMENU_OBJECT MenuObject, SubMenu;
54 PMENU_ITEM MenuItem;
55
56 ASSERT_REFS_CO(Window);
57
58 hWnd = Window->head.h;
59
60 TRACE("IntTranslateAccelerator(hwnd %x, message %x, wParam %x, lParam %x, fVirt %d, key %x, cmd %x)\n",
61 hWnd, pMsg->message, pMsg->wParam, pMsg->lParam, pAccel->fVirt, pAccel->key, pAccel->cmd);
62
63 if (UserGetKeyState(VK_CONTROL) & 0x8000) Mask |= FCONTROL;
64 if (UserGetKeyState(VK_MENU) & 0x8000) Mask |= FALT; // FIXME: VK_LMENU (msg winetest!)
65 if (UserGetKeyState(VK_SHIFT) & 0x8000) Mask |= FSHIFT;
66 TRACE("Mask 0x%x\n", Mask);
67
68 if (pAccel->fVirt & FVIRTKEY)
69 {
70 /* This is a virtual key. Process WM_(SYS)KEYDOWN messages. */
71 if (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN)
72 {
73 /* Check virtual key and SHIFT, CTRL, LALT state */
74 if (pMsg->wParam == pAccel->key && Mask == (pAccel->fVirt & (FSHIFT | FCONTROL | FALT)))
75 {
76 bFound = TRUE;
77 }
78 }
79 }
80 else
81 {
82 /* This is a char code. Process WM_(SYS)CHAR messages. */
83 if (pMsg->message == WM_CHAR || pMsg->message == WM_SYSCHAR)
84 {
85 /* Check char code and LALT state only */
86 if (pMsg->wParam == pAccel->key && (Mask & FALT) == (pAccel->fVirt & FALT))
87 {
88 bFound = TRUE;
89 }
90 }
91 }
92
93 if (!bFound)
94 {
95 /* Don't translate this msg */
96 TRACE("IntTranslateAccelerator returns FALSE\n");
97 return FALSE;
98 }
99
100 /* Check if accelerator is associated with menu command */
101 hMenu = (Window->style & WS_CHILD) ? 0 : (HMENU)Window->IDMenu;
102 hSubMenu = NULL;
103 MenuObject = IntGetMenuObject(hMenu);
104 if (MenuObject)
105 {
106 nPos = IntGetMenuItemByFlag(MenuObject,
107 pAccel->cmd,
108 MF_BYCOMMAND,
109 &SubMenu,
110 &MenuItem,
111 NULL);
112 if (nPos != (UINT)-1)
113 hSubMenu = SubMenu->head.h;
114 else
115 hMenu = NULL;
116 }
117 if (!hMenu)
118 {
119 /* Check system menu now */
120 hMenu = Window->SystemMenu;
121 hSubMenu = hMenu; /* system menu is a popup menu */
122 MenuObject = IntGetMenuObject(hMenu);
123 if (MenuObject)
124 {
125 nPos = IntGetMenuItemByFlag(MenuObject,
126 pAccel->cmd,
127 MF_BYCOMMAND,
128 &SubMenu,
129 &MenuItem,
130 NULL);
131 if (nPos != (UINT)-1)
132 hSubMenu = SubMenu->head.h;
133 else
134 hMenu = NULL;
135 }
136 }
137
138 /* If this is a menu item, there is no capturing enabled and
139 window is not disabled, send WM_INITMENU */
140 if (hMenu && !IntGetCaptureWindow())
141 {
142 co_IntSendMessage(hWnd, WM_INITMENU, (WPARAM)hMenu, 0L);
143 if (hSubMenu)
144 {
145 nPos = IntFindSubMenu(&hMenu, hSubMenu);
146 TRACE("hSysMenu = %p, hSubMenu = %p, nPos = %d\n", hMenu, hSubMenu, nPos);
147 co_IntSendMessage(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, TRUE));
148 }
149 }
150
151 /* Don't send any message if:
152 - window is disabled
153 - menu item is disabled
154 - this is window menu and window is minimized */
155 if (!(Window->style & WS_DISABLED) &&
156 !(hMenu && IntGetMenuState(hMenu, pAccel->cmd, MF_BYCOMMAND) & (MF_DISABLED|MF_GRAYED)) &&
157 !(hMenu && hMenu == (HMENU)Window->IDMenu && (Window->style & WS_MINIMIZED)))
158 {
159 /* If this is system menu item, send WM_SYSCOMMAND, otherwise send WM_COMMAND */
160 if (hMenu && hMenu == Window->SystemMenu)
161 {
162 TRACE("Sending WM_SYSCOMMAND, wParam=%0x\n", pAccel->cmd);
163 co_IntSendMessage(hWnd, WM_SYSCOMMAND, pAccel->cmd, 0x00010000L);
164 }
165 else
166 {
167 TRACE("Sending WM_COMMAND, wParam=%0x\n", 0x10000 | pAccel->cmd);
168 co_IntSendMessage(hWnd, WM_COMMAND, 0x10000 | pAccel->cmd, 0L);
169 }
170 }
171
172 TRACE("IntTranslateAccelerator returns TRUE\n");
173 return TRUE;
174 }
175
176
177 /* SYSCALLS *****************************************************************/
178
179
180 int
181 APIENTRY
182 NtUserCopyAcceleratorTable(
183 HACCEL hAccel,
184 LPACCEL Entries,
185 int EntriesCount)
186 {
187 PACCELERATOR_TABLE Accel;
188 int Ret;
189 DECLARE_RETURN(int);
190
191 TRACE("Enter NtUserCopyAcceleratorTable\n");
192 UserEnterShared();
193
194 Accel = UserGetAccelObject(hAccel);
195 if (!Accel)
196 {
197 RETURN(0);
198 }
199
200 /* If Entries is NULL return table size */
201 if (!Entries)
202 {
203 RETURN(Accel->Count);
204 }
205
206 /* Don't overrun */
207 if (Accel->Count < EntriesCount)
208 EntriesCount = Accel->Count;
209
210 Ret = 0;
211
212 _SEH2_TRY
213 {
214 ProbeForWrite(Entries, EntriesCount*sizeof(Entries[0]), 4);
215
216 for (Ret = 0; Ret < EntriesCount; Ret++)
217 {
218 Entries[Ret].fVirt = Accel->Table[Ret].fVirt;
219 Entries[Ret].key = Accel->Table[Ret].key;
220 Entries[Ret].cmd = Accel->Table[Ret].cmd;
221 }
222 }
223 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
224 {
225 SetLastNtError(_SEH2_GetExceptionCode());
226 Ret = 0;
227 }
228 _SEH2_END;
229
230 RETURN(Ret);
231
232 CLEANUP:
233 TRACE("Leave NtUserCopyAcceleratorTable, ret=%i\n", _ret_);
234 UserLeave();
235 END_CLEANUP;
236 }
237
238 HACCEL
239 APIENTRY
240 NtUserCreateAcceleratorTable(
241 LPACCEL Entries,
242 SIZE_T EntriesCount)
243 {
244 PACCELERATOR_TABLE Accel;
245 HACCEL hAccel;
246 INT Index;
247 NTSTATUS Status = STATUS_SUCCESS;
248 DECLARE_RETURN(HACCEL);
249
250 TRACE("Enter NtUserCreateAcceleratorTable(Entries %p, EntriesCount %d)\n",
251 Entries, EntriesCount);
252 UserEnterExclusive();
253
254 if (!Entries || EntriesCount <= 0)
255 {
256 SetLastNtError(STATUS_INVALID_PARAMETER);
257 RETURN( (HACCEL) NULL );
258 }
259
260 Accel = UserCreateObject(gHandleTable, NULL, (PHANDLE)&hAccel, otAccel, sizeof(ACCELERATOR_TABLE));
261
262 if (Accel == NULL)
263 {
264 SetLastNtError(STATUS_NO_MEMORY);
265 RETURN( (HACCEL) NULL );
266 }
267
268 Accel->Count = EntriesCount;
269 Accel->Table = ExAllocatePoolWithTag(PagedPool, EntriesCount * sizeof(ACCEL), USERTAG_ACCEL);
270 if (Accel->Table == NULL)
271 {
272 UserDereferenceObject(Accel);
273 UserDeleteObject(hAccel, otAccel);
274 SetLastNtError(STATUS_NO_MEMORY);
275 RETURN( (HACCEL) NULL);
276 }
277
278 _SEH2_TRY
279 {
280 ProbeForRead(Entries, EntriesCount * sizeof(ACCEL), 4);
281
282 for (Index = 0; Index < EntriesCount; Index++)
283 {
284 Accel->Table[Index].fVirt = Entries[Index].fVirt & FVIRT_MASK;
285 if(Accel->Table[Index].fVirt & FVIRTKEY)
286 {
287 Accel->Table[Index].key = Entries[Index].key;
288 }
289 else
290 {
291 RtlMultiByteToUnicodeN(&Accel->Table[Index].key,
292 sizeof(WCHAR),
293 NULL,
294 (PCSTR)&Entries[Index].key,
295 sizeof(CHAR));
296 }
297
298 Accel->Table[Index].cmd = Entries[Index].cmd;
299 }
300 }
301 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
302 {
303 Status = _SEH2_GetExceptionCode();
304 }
305 _SEH2_END;
306
307 if (!NT_SUCCESS(Status))
308 {
309 ExFreePoolWithTag(Accel->Table, USERTAG_ACCEL);
310 UserDereferenceObject(Accel);
311 UserDeleteObject(hAccel, otAccel);
312 SetLastNtError(Status);
313 RETURN( (HACCEL) NULL);
314 }
315
316 /* FIXME: Save HandleTable in a list somewhere so we can clean it up again */
317
318 RETURN(hAccel);
319
320 CLEANUP:
321 TRACE("Leave NtUserCreateAcceleratorTable(Entries %p, EntriesCount %d) = %x\n",
322 Entries, EntriesCount, _ret_);
323 UserLeave();
324 END_CLEANUP;
325 }
326
327 BOOLEAN
328 APIENTRY
329 NtUserDestroyAcceleratorTable(
330 HACCEL hAccel)
331 {
332 PACCELERATOR_TABLE Accel;
333 DECLARE_RETURN(BOOLEAN);
334
335 /* FIXME: If the handle table is from a call to LoadAcceleratorTable, decrement it's
336 usage count (and return TRUE).
337 FIXME: Destroy only tables created using CreateAcceleratorTable.
338 */
339
340 TRACE("NtUserDestroyAcceleratorTable(Table %x)\n", hAccel);
341 UserEnterExclusive();
342
343 if (!(Accel = UserGetAccelObject(hAccel)))
344 {
345 RETURN( FALSE);
346 }
347
348 if (Accel->Table != NULL)
349 {
350 ExFreePoolWithTag(Accel->Table, USERTAG_ACCEL);
351 Accel->Table = NULL;
352 }
353
354 UserDeleteObject(hAccel, otAccel);
355
356 RETURN( TRUE);
357
358 CLEANUP:
359 TRACE("Leave NtUserDestroyAcceleratorTable(Table %x) = %i\n", hAccel,_ret_);
360 UserLeave();
361 END_CLEANUP;
362 }
363
364 int
365 APIENTRY
366 NtUserTranslateAccelerator(
367 HWND hWnd,
368 HACCEL hAccel,
369 LPMSG pUnsafeMessage)
370 {
371 PWND Window = NULL;
372 PACCELERATOR_TABLE Accel = NULL;
373 ULONG i;
374 MSG Message;
375 USER_REFERENCE_ENTRY AccelRef, WindowRef;
376 DECLARE_RETURN(int);
377
378 TRACE("NtUserTranslateAccelerator(hWnd %x, Table %x, Message %p)\n",
379 hWnd, hAccel, pUnsafeMessage);
380 UserEnterShared();
381
382 if (hWnd == NULL)
383 {
384 RETURN( 0);
385 }
386
387 _SEH2_TRY
388 {
389 ProbeForRead(pUnsafeMessage, sizeof(MSG), 4);
390 RtlCopyMemory(&Message, pUnsafeMessage, sizeof(MSG));
391 }
392 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
393 {
394 SetLastNtError(_SEH2_GetExceptionCode());
395 _SEH2_YIELD(RETURN( 0));
396 }
397 _SEH2_END;
398
399 if ((Message.message != WM_KEYDOWN) &&
400 (Message.message != WM_SYSKEYDOWN) &&
401 (Message.message != WM_SYSCHAR) &&
402 (Message.message != WM_CHAR))
403 {
404 RETURN( 0);
405 }
406
407 Accel = UserGetAccelObject(hAccel);
408 if (!Accel)
409 {
410 RETURN( 0);
411 }
412
413 UserRefObjectCo(Accel, &AccelRef);
414
415 Window = UserGetWindowObject(hWnd);
416 if (!Window)
417 {
418 RETURN( 0);
419 }
420
421 UserRefObjectCo(Window, &WindowRef);
422
423 /* FIXME: Associate AcceleratorTable with the current thread */
424
425 for (i = 0; i < Accel->Count; i++)
426 {
427 if (co_IntTranslateAccelerator(Window, &Message, &Accel->Table[i]))
428 {
429 RETURN( 1);
430 }
431
432 /* Undocumented feature... */
433 if (Accel->Table[i].fVirt & FVIRT_TBL_END)
434 break;
435 }
436
437 RETURN( 0);
438
439 CLEANUP:
440 if (Window) UserDerefObjectCo(Window);
441 if (Accel) UserDerefObjectCo(Accel);
442
443 TRACE("NtUserTranslateAccelerator returns %d\n", _ret_);
444 UserLeave();
445 END_CLEANUP;
446 }