Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-10 12:44:21 +00:00
Code Issues Projects Releases Packages Wiki Activity

[WIN32K] - Formatting... No code change.

Browse source 
svn path=/trunk/; revision=54066
This commit is contained in:
Rafal Harabien 2011-10-09 20:41:09 +00:00
parent 28e930a691
commit b63c511bbf
2 changed files with 499 additions and 499 deletions
Download patch file Download diff file Expand all files Collapse all files

652
reactos/subsystems/win32/win32k/ntuser/accelerator.c
View file

@ -20,157 +20,157 @@ DBG_DEFAULT_CHANNEL(UserAccel);
PACCELERATOR_TABLE FASTCALL UserGetAccelObject(HACCEL hAccel) PACCELERATOR_TABLE FASTCALL UserGetAccelObject(HACCEL hAccel)
{ {
PACCELERATOR_TABLE Accel; PACCELERATOR_TABLE Accel;
if (!hAccel) if (!hAccel)
{ {
EngSetLastError(ERROR_INVALID_ACCEL_HANDLE); EngSetLastError(ERROR_INVALID_ACCEL_HANDLE);
return NULL; return NULL;
} }
Accel= UserGetObject(gHandleTable, hAccel, otAccel); Accel = UserGetObject(gHandleTable, hAccel, otAccel);
if (!Accel) if (!Accel)
{ {
EngSetLastError(ERROR_INVALID_ACCEL_HANDLE); EngSetLastError(ERROR_INVALID_ACCEL_HANDLE);
return NULL; return NULL;
} }
return Accel; return Accel;
} }
static static
BOOLEAN FASTCALL BOOLEAN FASTCALL
co_IntTranslateAccelerator( co_IntTranslateAccelerator(
PWND Window, PWND Window,
CONST MSG *pMsg, CONST MSG *pMsg,
CONST ACCEL *pAccel) CONST ACCEL *pAccel)
{ {
BOOL bFound = FALSE; BOOL bFound = FALSE;
UINT Mask = 0, nPos; UINT Mask = 0, nPos;
HWND hWnd; HWND hWnd;
HMENU hMenu, hSubMenu; HMENU hMenu, hSubMenu;
PMENU_OBJECT MenuObject, SubMenu; PMENU_OBJECT MenuObject, SubMenu;
PMENU_ITEM MenuItem; PMENU_ITEM MenuItem;
ASSERT_REFS_CO(Window); ASSERT_REFS_CO(Window);
hWnd = Window->head.h; hWnd = Window->head.h;
TRACE("IntTranslateAccelerator(hwnd %x, message %x, wParam %x, lParam %x, fVirt %d, key %x, cmd %x)\n", TRACE("IntTranslateAccelerator(hwnd %x, message %x, wParam %x, lParam %x, fVirt %d, key %x, cmd %x)\n",
hWnd, pMsg->message, pMsg->wParam, pMsg->lParam, pAccel->fVirt, pAccel->key, pAccel->cmd); hWnd, pMsg->message, pMsg->wParam, pMsg->lParam, pAccel->fVirt, pAccel->key, pAccel->cmd);
if (UserGetKeyState(VK_CONTROL) & 0x8000) Mask |= FCONTROL; if (UserGetKeyState(VK_CONTROL) & 0x8000) Mask |= FCONTROL;
if (UserGetKeyState(VK_MENU) & 0x8000) Mask |= FALT; // FIXME: VK_LMENU (msg winetest!) if (UserGetKeyState(VK_MENU) & 0x8000) Mask |= FALT; // FIXME: VK_LMENU (msg winetest!)
if (UserGetKeyState(VK_SHIFT) & 0x8000) Mask |= FSHIFT; if (UserGetKeyState(VK_SHIFT) & 0x8000) Mask |= FSHIFT;
TRACE("Mask 0x%x\n", Mask); TRACE("Mask 0x%x\n", Mask);
if (pAccel->fVirt & FVIRTKEY) if (pAccel->fVirt & FVIRTKEY)
{ {
/* This is a virtual key. Process WM_(SYS)KEYDOWN messages. */ /* This is a virtual key. Process WM_(SYS)KEYDOWN messages. */
if (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN) if (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN)
{ {
/* Check virtual key and SHIFT, CTRL, LALT state */ /* Check virtual key and SHIFT, CTRL, LALT state */
if (pMsg->wParam == pAccel->key && Mask == (pAccel->fVirt & (FSHIFT | FCONTROL | FALT))) if (pMsg->wParam == pAccel->key && Mask == (pAccel->fVirt & (FSHIFT | FCONTROL | FALT)))
{ {
bFound = TRUE; bFound = TRUE;
} }
} }
} }
else else
{ {
/* This is a char code. Process WM_(SYS)CHAR messages. */ /* This is a char code. Process WM_(SYS)CHAR messages. */
if (pMsg->message == WM_CHAR || pMsg->message == WM_SYSCHAR) if (pMsg->message == WM_CHAR || pMsg->message == WM_SYSCHAR)
{ {
/* Check char code and LALT state only */ /* Check char code and LALT state only */
if (pMsg->wParam == pAccel->key && (Mask & FALT) == (pAccel->fVirt & FALT)) if (pMsg->wParam == pAccel->key && (Mask & FALT) == (pAccel->fVirt & FALT))
{ {
bFound = TRUE; bFound = TRUE;
} }
} }
} }
if (!bFound) if (!bFound)
{ {
/* Don't translate this msg */ /* Don't translate this msg */
TRACE("IntTranslateAccelerator returns FALSE\n"); TRACE("IntTranslateAccelerator returns FALSE\n");
return FALSE; return FALSE;
} }
/* Check if accelerator is associated with menu command */ /* Check if accelerator is associated with menu command */
hMenu = (Window->style & WS_CHILD) ? 0 : (HMENU)Window->IDMenu; hMenu = (Window->style & WS_CHILD) ? 0 : (HMENU)Window->IDMenu;
hSubMenu = NULL; hSubMenu = NULL;
MenuObject = IntGetMenuObject(hMenu); MenuObject = IntGetMenuObject(hMenu);
if (MenuObject) if (MenuObject)
{ {
nPos = IntGetMenuItemByFlag(MenuObject, nPos = IntGetMenuItemByFlag(MenuObject,
pAccel->cmd, pAccel->cmd,
MF_BYCOMMAND, MF_BYCOMMAND,
&SubMenu, &SubMenu,
&MenuItem, &MenuItem,
NULL); NULL);
if (nPos != (UINT)-1) if (nPos != (UINT) - 1)
hSubMenu = SubMenu->head.h; hSubMenu = SubMenu->head.h;
else else
hMenu = NULL; hMenu = NULL;
} }
if (!hMenu) if (!hMenu)
{ {
/* Check system menu now */ /* Check system menu now */
hMenu = Window->SystemMenu; hMenu = Window->SystemMenu;
hSubMenu = hMenu; /* system menu is a popup menu */ hSubMenu = hMenu; /* system menu is a popup menu */
MenuObject = IntGetMenuObject(hMenu); MenuObject = IntGetMenuObject(hMenu);
if (MenuObject) if (MenuObject)
{ {
nPos = IntGetMenuItemByFlag(MenuObject, nPos = IntGetMenuItemByFlag(MenuObject,
pAccel->cmd, pAccel->cmd,
MF_BYCOMMAND, MF_BYCOMMAND,
&SubMenu, &SubMenu,
&MenuItem, &MenuItem,
NULL); NULL);
if (nPos != (UINT)-1) if (nPos != (UINT) - 1)
hSubMenu = SubMenu->head.h; hSubMenu = SubMenu->head.h;
else else
hMenu = NULL; hMenu = NULL;
} }
} }
/* If this is a menu item, there is no capturing enabled and /* If this is a menu item, there is no capturing enabled and
window is not disabled, send WM_INITMENU */ window is not disabled, send WM_INITMENU */
if (hMenu && !IntGetCaptureWindow()) if (hMenu && !IntGetCaptureWindow())
{ {
co_IntSendMessage(hWnd, WM_INITMENU, (WPARAM)hMenu, 0L); co_IntSendMessage(hWnd, WM_INITMENU, (WPARAM)hMenu, 0L);
if (hSubMenu) if (hSubMenu)
{ {
nPos = IntFindSubMenu(&hMenu, hSubMenu); nPos = IntFindSubMenu(&hMenu, hSubMenu);
TRACE("hSysMenu = %p, hSubMenu = %p, nPos = %d\n", hMenu, hSubMenu, nPos); TRACE("hSysMenu = %p, hSubMenu = %p, nPos = %d\n", hMenu, hSubMenu, nPos);
co_IntSendMessage(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, TRUE)); co_IntSendMessage(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, TRUE));
} }
} }
/* Don't send any message if: /* Don't send any message if:
- window is disabled - window is disabled
- menu item is disabled - menu item is disabled
- this is window menu and window is minimized */ - this is window menu and window is minimized */
if (!(Window->style & WS_DISABLED) && if (!(Window->style & WS_DISABLED) &&
!(hMenu && IntGetMenuState(hMenu, pAccel->cmd, MF_BYCOMMAND) & (MF_DISABLED|MF_GRAYED)) && !(hMenu && IntGetMenuState(hMenu, pAccel->cmd, MF_BYCOMMAND) & (MF_DISABLED | MF_GRAYED)) &&
!(hMenu && hMenu == (HMENU)Window->IDMenu && (Window->style & WS_MINIMIZED))) !(hMenu && hMenu == (HMENU)Window->IDMenu && (Window->style & WS_MINIMIZED)))
{ {
/* If this is system menu item, send WM_SYSCOMMAND, otherwise send WM_COMMAND */ /* If this is system menu item, send WM_SYSCOMMAND, otherwise send WM_COMMAND */
if (hMenu && hMenu == Window->SystemMenu) if (hMenu && hMenu == Window->SystemMenu)
{ {
TRACE("Sending WM_SYSCOMMAND, wParam=%0x\n", pAccel->cmd); TRACE("Sending WM_SYSCOMMAND, wParam=%0x\n", pAccel->cmd);
co_IntSendMessage(hWnd, WM_SYSCOMMAND, pAccel->cmd, 0x00010000L); co_IntSendMessage(hWnd, WM_SYSCOMMAND, pAccel->cmd, 0x00010000L);
} }
else else
{ {
TRACE("Sending WM_COMMAND, wParam=%0x\n", 0x10000 | pAccel->cmd); TRACE("Sending WM_COMMAND, wParam=%0x\n", 0x10000 | pAccel->cmd);
co_IntSendMessage(hWnd, WM_COMMAND, 0x10000 | pAccel->cmd, 0L); co_IntSendMessage(hWnd, WM_COMMAND, 0x10000 | pAccel->cmd, 0L);
} }
} }
TRACE("IntTranslateAccelerator returns TRUE\n"); TRACE("IntTranslateAccelerator returns TRUE\n");
return TRUE; return TRUE;
} }
@ -180,267 +180,267 @@ co_IntTranslateAccelerator(
int int
APIENTRY APIENTRY
NtUserCopyAcceleratorTable( NtUserCopyAcceleratorTable(
HACCEL hAccel, HACCEL hAccel,
LPACCEL Entries, LPACCEL Entries,
int EntriesCount) int EntriesCount)
{ {
PACCELERATOR_TABLE Accel; PACCELERATOR_TABLE Accel;
int Ret; int Ret;
DECLARE_RETURN(int); DECLARE_RETURN(int);
TRACE("Enter NtUserCopyAcceleratorTable\n"); TRACE("Enter NtUserCopyAcceleratorTable\n");
UserEnterShared(); UserEnterShared();
Accel = UserGetAccelObject(hAccel); Accel = UserGetAccelObject(hAccel);
if (!Accel) if (!Accel)
{ {
RETURN(0); RETURN(0);
} }
/* If Entries is NULL return table size */ /* If Entries is NULL return table size */
if (!Entries) if (!Entries)
{ {
RETURN(Accel->Count); RETURN(Accel->Count);
} }
/* Don't overrun */ /* Don't overrun */
if (Accel->Count < EntriesCount) if (Accel->Count < EntriesCount)
EntriesCount = Accel->Count; EntriesCount = Accel->Count;
Ret = 0; Ret = 0;
_SEH2_TRY _SEH2_TRY
{ {
ProbeForWrite(Entries, EntriesCount*sizeof(Entries[0]), 4); ProbeForWrite(Entries, EntriesCount*sizeof(Entries[0]), 4);
for (Ret = 0; Ret < EntriesCount; Ret++) for (Ret = 0; Ret < EntriesCount; Ret++)
{ {
Entries[Ret].fVirt = Accel->Table[Ret].fVirt; Entries[Ret].fVirt = Accel->Table[Ret].fVirt;
Entries[Ret].key = Accel->Table[Ret].key; Entries[Ret].key = Accel->Table[Ret].key;
Entries[Ret].cmd = Accel->Table[Ret].cmd; Entries[Ret].cmd = Accel->Table[Ret].cmd;
} }
} }
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{ {
SetLastNtError(_SEH2_GetExceptionCode()); SetLastNtError(_SEH2_GetExceptionCode());
Ret = 0; Ret = 0;
} }
_SEH2_END; _SEH2_END;
RETURN(Ret); RETURN(Ret);
CLEANUP: CLEANUP:
TRACE("Leave NtUserCopyAcceleratorTable, ret=%i\n", _ret_); TRACE("Leave NtUserCopyAcceleratorTable, ret=%i\n", _ret_);
UserLeave(); UserLeave();
END_CLEANUP; END_CLEANUP;
} }
HACCEL HACCEL
APIENTRY APIENTRY
NtUserCreateAcceleratorTable( NtUserCreateAcceleratorTable(
LPACCEL Entries, LPACCEL Entries,
SIZE_T EntriesCount) SIZE_T EntriesCount)
{ {
PACCELERATOR_TABLE Accel; PACCELERATOR_TABLE Accel;
HACCEL hAccel; HACCEL hAccel;
INT Index; INT Index;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
DECLARE_RETURN(HACCEL); DECLARE_RETURN(HACCEL);
TRACE("Enter NtUserCreateAcceleratorTable(Entries %p, EntriesCount %d)\n", TRACE("Enter NtUserCreateAcceleratorTable(Entries %p, EntriesCount %d)\n",
Entries, EntriesCount); Entries, EntriesCount);
UserEnterExclusive(); UserEnterExclusive();
if (!Entries || EntriesCount <= 0) if (!Entries || EntriesCount <= 0)
{ {
SetLastNtError(STATUS_INVALID_PARAMETER); SetLastNtError(STATUS_INVALID_PARAMETER);
RETURN( (HACCEL) NULL ); RETURN( (HACCEL) NULL );
} }
Accel = UserCreateObject(gHandleTable, NULL, (PHANDLE)&hAccel, otAccel, sizeof(ACCELERATOR_TABLE)); Accel = UserCreateObject(gHandleTable, NULL, (PHANDLE)&hAccel, otAccel, sizeof(ACCELERATOR_TABLE));
if (Accel == NULL) if (Accel == NULL)
{ {
SetLastNtError(STATUS_NO_MEMORY); SetLastNtError(STATUS_NO_MEMORY);
RETURN( (HACCEL) NULL ); RETURN( (HACCEL) NULL );
} }
Accel->Count = EntriesCount; Accel->Count = EntriesCount;
Accel->Table = ExAllocatePoolWithTag(PagedPool, EntriesCount * sizeof(ACCEL), USERTAG_ACCEL); Accel->Table = ExAllocatePoolWithTag(PagedPool, EntriesCount * sizeof(ACCEL), USERTAG_ACCEL);
if (Accel->Table == NULL) if (Accel->Table == NULL)
{ {
UserDereferenceObject(Accel); UserDereferenceObject(Accel);
UserDeleteObject(hAccel, otAccel); UserDeleteObject(hAccel, otAccel);
SetLastNtError(STATUS_NO_MEMORY); SetLastNtError(STATUS_NO_MEMORY);
RETURN( (HACCEL) NULL); RETURN( (HACCEL) NULL);
} }
_SEH2_TRY _SEH2_TRY
{ {
ProbeForRead(Entries, EntriesCount * sizeof(ACCEL), 4); ProbeForRead(Entries, EntriesCount * sizeof(ACCEL), 4);
for (Index = 0; Index < EntriesCount; Index++) for (Index = 0; Index < EntriesCount; Index++)
{ {
Accel->Table[Index].fVirt = Entries[Index].fVirt & FVIRT_MASK; Accel->Table[Index].fVirt = Entries[Index].fVirt & FVIRT_MASK;
if(Accel->Table[Index].fVirt & FVIRTKEY) if(Accel->Table[Index].fVirt & FVIRTKEY)
{ {
Accel->Table[Index].key = Entries[Index].key; Accel->Table[Index].key = Entries[Index].key;
} }
else else
{ {
RtlMultiByteToUnicodeN(&Accel->Table[Index].key, RtlMultiByteToUnicodeN(&Accel->Table[Index].key,
sizeof(WCHAR), sizeof(WCHAR),
NULL, NULL,
(PCSTR)&Entries[Index].key, (PCSTR)&Entries[Index].key,
sizeof(CHAR)); sizeof(CHAR));
} }
Accel->Table[Index].cmd = Entries[Index].cmd; Accel->Table[Index].cmd = Entries[Index].cmd;
} }
} }
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{ {
Status = _SEH2_GetExceptionCode(); Status = _SEH2_GetExceptionCode();
} }
_SEH2_END; _SEH2_END;
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ExFreePoolWithTag(Accel->Table, USERTAG_ACCEL); ExFreePoolWithTag(Accel->Table, USERTAG_ACCEL);
UserDereferenceObject(Accel); UserDereferenceObject(Accel);
UserDeleteObject(hAccel, otAccel); UserDeleteObject(hAccel, otAccel);
SetLastNtError(Status); SetLastNtError(Status);
RETURN( (HACCEL) NULL); RETURN( (HACCEL) NULL);
} }
/* FIXME: Save HandleTable in a list somewhere so we can clean it up again */ /* FIXME: Save HandleTable in a list somewhere so we can clean it up again */
RETURN(hAccel); RETURN(hAccel);
CLEANUP: CLEANUP:
TRACE("Leave NtUserCreateAcceleratorTable(Entries %p, EntriesCount %d) = %x\n", TRACE("Leave NtUserCreateAcceleratorTable(Entries %p, EntriesCount %d) = %x\n",
Entries, EntriesCount, _ret_); Entries, EntriesCount, _ret_);
UserLeave(); UserLeave();
END_CLEANUP; END_CLEANUP;
} }
BOOLEAN BOOLEAN
APIENTRY APIENTRY
NtUserDestroyAcceleratorTable( NtUserDestroyAcceleratorTable(
HACCEL hAccel) HACCEL hAccel)
{ {
PACCELERATOR_TABLE Accel; PACCELERATOR_TABLE Accel;
DECLARE_RETURN(BOOLEAN); DECLARE_RETURN(BOOLEAN);
/* FIXME: If the handle table is from a call to LoadAcceleratorTable, decrement it's /* FIXME: If the handle table is from a call to LoadAcceleratorTable, decrement it's
usage count (and return TRUE). usage count (and return TRUE).
FIXME: Destroy only tables created using CreateAcceleratorTable. FIXME: Destroy only tables created using CreateAcceleratorTable.
*/ */
TRACE("NtUserDestroyAcceleratorTable(Table %x)\n", hAccel); TRACE("NtUserDestroyAcceleratorTable(Table %x)\n", hAccel);
UserEnterExclusive(); UserEnterExclusive();
if (!(Accel = UserGetAccelObject(hAccel))) if (!(Accel = UserGetAccelObject(hAccel)))
{ {
RETURN( FALSE); RETURN( FALSE);
} }
if (Accel->Table != NULL) if (Accel->Table != NULL)
{ {
ExFreePoolWithTag(Accel->Table, USERTAG_ACCEL); ExFreePoolWithTag(Accel->Table, USERTAG_ACCEL);
Accel->Table = NULL; Accel->Table = NULL;
} }
UserDeleteObject(hAccel, otAccel); UserDeleteObject(hAccel, otAccel);
RETURN( TRUE); RETURN( TRUE);
CLEANUP: CLEANUP:
TRACE("Leave NtUserDestroyAcceleratorTable(Table %x) = %i\n", hAccel,_ret_); TRACE("Leave NtUserDestroyAcceleratorTable(Table %x) = %i\n", hAccel, _ret_);
UserLeave(); UserLeave();
END_CLEANUP; END_CLEANUP;
} }
int int
APIENTRY APIENTRY
NtUserTranslateAccelerator( NtUserTranslateAccelerator(
HWND hWnd, HWND hWnd,
HACCEL hAccel, HACCEL hAccel,
LPMSG pUnsafeMessage) LPMSG pUnsafeMessage)
{ {
PWND Window = NULL; PWND Window = NULL;
PACCELERATOR_TABLE Accel = NULL; PACCELERATOR_TABLE Accel = NULL;
ULONG i; ULONG i;
MSG Message; MSG Message;
USER_REFERENCE_ENTRY AccelRef, WindowRef; USER_REFERENCE_ENTRY AccelRef, WindowRef;
DECLARE_RETURN(int); DECLARE_RETURN(int);
TRACE("NtUserTranslateAccelerator(hWnd %x, Table %x, Message %p)\n", TRACE("NtUserTranslateAccelerator(hWnd %x, Table %x, Message %p)\n",
hWnd, hAccel, pUnsafeMessage); hWnd, hAccel, pUnsafeMessage);
UserEnterShared(); UserEnterShared();
if (hWnd == NULL) if (hWnd == NULL)
{ {
RETURN( 0); RETURN( 0);
} }
_SEH2_TRY _SEH2_TRY
{ {
ProbeForRead(pUnsafeMessage, sizeof(MSG), 4); ProbeForRead(pUnsafeMessage, sizeof(MSG), 4);
RtlCopyMemory(&Message, pUnsafeMessage, sizeof(MSG)); RtlCopyMemory(&Message, pUnsafeMessage, sizeof(MSG));
} }
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{ {
SetLastNtError(_SEH2_GetExceptionCode()); SetLastNtError(_SEH2_GetExceptionCode());
_SEH2_YIELD(RETURN( 0)); _SEH2_YIELD(RETURN( 0));
} }
_SEH2_END; _SEH2_END;
if ((Message.message != WM_KEYDOWN) && if ((Message.message != WM_KEYDOWN) &&
(Message.message != WM_SYSKEYDOWN) && (Message.message != WM_SYSKEYDOWN) &&
(Message.message != WM_SYSCHAR) && (Message.message != WM_SYSCHAR) &&
(Message.message != WM_CHAR)) (Message.message != WM_CHAR))
{ {
RETURN( 0); RETURN( 0);
} }
Accel = UserGetAccelObject(hAccel); Accel = UserGetAccelObject(hAccel);
if (!Accel) if (!Accel)
{ {
RETURN( 0); RETURN( 0);
} }
UserRefObjectCo(Accel, &AccelRef); UserRefObjectCo(Accel, &AccelRef);
Window = UserGetWindowObject(hWnd); Window = UserGetWindowObject(hWnd);
if (!Window) if (!Window)
{ {
RETURN( 0); RETURN( 0);
} }
UserRefObjectCo(Window, &WindowRef); UserRefObjectCo(Window, &WindowRef);
/* FIXME: Associate AcceleratorTable with the current thread */ /* FIXME: Associate AcceleratorTable with the current thread */
for (i = 0; i < Accel->Count; i++) for (i = 0; i < Accel->Count; i++)
{ {
if (co_IntTranslateAccelerator(Window, &Message, &Accel->Table[i])) if (co_IntTranslateAccelerator(Window, &Message, &Accel->Table[i]))
{ {
RETURN( 1); RETURN( 1);
} }
/* Undocumented feature... */ /* Undocumented feature... */
if (Accel->Table[i].fVirt & FVIRT_TBL_END) if (Accel->Table[i].fVirt & FVIRT_TBL_END)
break; break;
} }
RETURN( 0); RETURN( 0);
CLEANUP: CLEANUP:
if (Window) UserDerefObjectCo(Window); if (Window) UserDerefObjectCo(Window);
if (Accel) UserDerefObjectCo(Accel); if (Accel) UserDerefObjectCo(Accel);
TRACE("NtUserTranslateAccelerator returns %d\n", _ret_); TRACE("NtUserTranslateAccelerator returns %d\n", _ret_);
UserLeave(); UserLeave();
END_CLEANUP; END_CLEANUP;
} }

346
reactos/subsystems/win32/win32k/ntuser/hotkey.c
View file

@ -28,9 +28,9 @@ NTSTATUS
NTAPI NTAPI
InitHotkeyImpl(VOID) InitHotkeyImpl(VOID)
{ {
InitializeListHead(&gHotkeyList); InitializeListHead(&gHotkeyList);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
#if 0 //not used #if 0 //not used
@ -38,7 +38,7 @@ NTSTATUS FASTCALL
CleanupHotKeys(VOID) CleanupHotKeys(VOID)
{ {
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
#endif #endif
@ -53,7 +53,7 @@ UINT FASTCALL
IntGetModifiers(PBYTE pKeyState) IntGetModifiers(PBYTE pKeyState)
{ {
UINT fModifiers = 0; UINT fModifiers = 0;
if (IS_KEY_DOWN(pKeyState, VK_SHIFT)) if (IS_KEY_DOWN(pKeyState, VK_SHIFT))
fModifiers |= MOD_SHIFT; fModifiers |= MOD_SHIFT;
@ -72,48 +72,48 @@ IntGetModifiers(PBYTE pKeyState)
VOID FASTCALL VOID FASTCALL
UnregisterWindowHotKeys(PWND Window) UnregisterWindowHotKeys(PWND Window)
{ {
PHOT_KEY_ITEM HotKeyItem, tmp; PHOT_KEY_ITEM HotKeyItem, tmp;
LIST_FOR_EACH_SAFE(HotKeyItem, tmp, &gHotkeyList, HOT_KEY_ITEM, ListEntry) LIST_FOR_EACH_SAFE(HotKeyItem, tmp, &gHotkeyList, HOT_KEY_ITEM, ListEntry)
{ {
if (HotKeyItem->hWnd == Window->head.h) if (HotKeyItem->hWnd == Window->head.h)
{ {
RemoveEntryList (&HotKeyItem->ListEntry); RemoveEntryList(&HotKeyItem->ListEntry);
ExFreePool (HotKeyItem); ExFreePool(HotKeyItem);
} }
} }
} }
VOID FASTCALL VOID FASTCALL
UnregisterThreadHotKeys(struct _ETHREAD *Thread) UnregisterThreadHotKeys(struct _ETHREAD *Thread)
{ {
PHOT_KEY_ITEM HotKeyItem, tmp; PHOT_KEY_ITEM HotKeyItem, tmp;
LIST_FOR_EACH_SAFE(HotKeyItem, tmp, &gHotkeyList, HOT_KEY_ITEM, ListEntry) LIST_FOR_EACH_SAFE(HotKeyItem, tmp, &gHotkeyList, HOT_KEY_ITEM, ListEntry)
{ {
if (HotKeyItem->Thread == Thread) if (HotKeyItem->Thread == Thread)
{ {
RemoveEntryList (&HotKeyItem->ListEntry); RemoveEntryList(&HotKeyItem->ListEntry);
ExFreePool (HotKeyItem); ExFreePool(HotKeyItem);
} }
} }
} }
PHOT_KEY_ITEM FASTCALL PHOT_KEY_ITEM FASTCALL
IsHotKey(UINT fsModifiers, WORD wVk) IsHotKey(UINT fsModifiers, WORD wVk)
{ {
PHOT_KEY_ITEM pHotKeyItem; PHOT_KEY_ITEM pHotKeyItem;
LIST_FOR_EACH(pHotKeyItem, &gHotkeyList, HOT_KEY_ITEM, ListEntry) LIST_FOR_EACH(pHotKeyItem, &gHotkeyList, HOT_KEY_ITEM, ListEntry)
{ {
if (pHotKeyItem->fsModifiers == fsModifiers && pHotKeyItem->vk == wVk) if (pHotKeyItem->fsModifiers == fsModifiers && pHotKeyItem->vk == wVk)
{ {
return pHotKeyItem; return pHotKeyItem;
} }
} }
return NULL; return NULL;
} }
/* /*
@ -177,106 +177,106 @@ co_UserProcessHotKeys(WORD wVk, BOOL bIsDown)
// Get/SetHotKey message support. // Get/SetHotKey message support.
// //
UINT FASTCALL UINT FASTCALL
DefWndGetHotKey( HWND hwnd ) DefWndGetHotKey(HWND hwnd)
{ {
PHOT_KEY_ITEM HotKeyItem; PHOT_KEY_ITEM HotKeyItem;
ERR("DefWndGetHotKey\n"); ERR("DefWndGetHotKey\n");
if (IsListEmpty(&gHotkeyList)) return 0; if (IsListEmpty(&gHotkeyList)) return 0;
LIST_FOR_EACH(HotKeyItem, &gHotkeyList, HOT_KEY_ITEM, ListEntry) LIST_FOR_EACH(HotKeyItem, &gHotkeyList, HOT_KEY_ITEM, ListEntry)
{ {
if ( HotKeyItem->hWnd == hwnd && if (HotKeyItem->hWnd == hwnd &&
HotKeyItem->id == IDHOT_REACTOS ) HotKeyItem->id == IDHOT_REACTOS)
{ {
return MAKELONG(HotKeyItem->vk, HotKeyItem->fsModifiers); return MAKELONG(HotKeyItem->vk, HotKeyItem->fsModifiers);
} }
} }
return 0; return 0;
} }
INT FASTCALL INT FASTCALL
DefWndSetHotKey( PWND pWnd, WPARAM wParam ) DefWndSetHotKey(PWND pWnd, WPARAM wParam)
{ {
UINT fsModifiers, vk; UINT fsModifiers, vk;
PHOT_KEY_ITEM HotKeyItem; PHOT_KEY_ITEM HotKeyItem;
HWND hWnd; HWND hWnd;
BOOL HaveSameWnd = FALSE; BOOL HaveSameWnd = FALSE;
INT Ret = 1; INT Ret = 1;
ERR("DefWndSetHotKey wParam 0x%x\n", wParam); ERR("DefWndSetHotKey wParam 0x%x\n", wParam);
// A hot key cannot be associated with a child window. // A hot key cannot be associated with a child window.
if (pWnd->style & WS_CHILD) return 0; if (pWnd->style & WS_CHILD) return 0;
// VK_ESCAPE, VK_SPACE, and VK_TAB are invalid hot keys. // VK_ESCAPE, VK_SPACE, and VK_TAB are invalid hot keys.
if ( LOWORD(wParam) == VK_ESCAPE || if (LOWORD(wParam) == VK_ESCAPE ||
LOWORD(wParam) == VK_SPACE || LOWORD(wParam) == VK_SPACE ||
LOWORD(wParam) == VK_TAB ) return -1; LOWORD(wParam) == VK_TAB) return -1;
vk = LOWORD(wParam); vk = LOWORD(wParam);
fsModifiers = HIWORD(wParam); fsModifiers = HIWORD(wParam);
hWnd = UserHMGetHandle(pWnd); hWnd = UserHMGetHandle(pWnd);
if (wParam) if (wParam)
{ {
LIST_FOR_EACH(HotKeyItem, &gHotkeyList, HOT_KEY_ITEM, ListEntry) LIST_FOR_EACH(HotKeyItem, &gHotkeyList, HOT_KEY_ITEM, ListEntry)
{ {
if ( HotKeyItem->fsModifiers == fsModifiers && if (HotKeyItem->fsModifiers == fsModifiers &&
HotKeyItem->vk == vk && HotKeyItem->vk == vk &&
HotKeyItem->id == IDHOT_REACTOS ) HotKeyItem->id == IDHOT_REACTOS)
{ {
if (HotKeyItem->hWnd != hWnd) if (HotKeyItem->hWnd != hWnd)
Ret = 2; // Another window already has the same hot key. Ret = 2; // Another window already has the same hot key.
break;
}
}
}
LIST_FOR_EACH(HotKeyItem, &gHotkeyList, HOT_KEY_ITEM, ListEntry)
{
if (HotKeyItem->hWnd == hWnd &&
HotKeyItem->id == IDHOT_REACTOS)
{
HaveSameWnd = TRUE;
break; break;
} }
} }
}
LIST_FOR_EACH(HotKeyItem, &gHotkeyList, HOT_KEY_ITEM, ListEntry) if (HaveSameWnd)
{ {
if ( HotKeyItem->hWnd == hWnd && if (wParam == 0)
HotKeyItem->id == IDHOT_REACTOS ) { // Setting wParam to NULL removes the hot key associated with a window.
{ UnregisterWindowHotKeys(pWnd);
HaveSameWnd = TRUE; }
break; else
} { /* A window can only have one hot key. If the window already has a hot key
} associated with it, the new hot key replaces the old one. */
HotKeyItem->fsModifiers = fsModifiers;
HotKeyItem->vk = vk;
}
}
else //
{
if (wParam == 0)
return 1; // Do nothing, exit.
if (HaveSameWnd) HotKeyItem = ExAllocatePoolWithTag(PagedPool, sizeof(HOT_KEY_ITEM), USERTAG_HOTKEY);
{ if (HotKeyItem == NULL)
if (wParam == 0) {
{ // Setting wParam to NULL removes the hot key associated with a window. return 0;
UnregisterWindowHotKeys(pWnd); }
}
else
{ /* A window can only have one hot key. If the window already has a hot key
associated with it, the new hot key replaces the old one. */
HotKeyItem->fsModifiers = fsModifiers;
HotKeyItem->vk = vk;
}
}
else //
{
if (wParam == 0)
return 1; // Do nothing, exit.
HotKeyItem = ExAllocatePoolWithTag (PagedPool, sizeof(HOT_KEY_ITEM), USERTAG_HOTKEY); HotKeyItem->Thread = pWnd->head.pti->pEThread;
if (HotKeyItem == NULL) HotKeyItem->hWnd = hWnd;
{ HotKeyItem->id = IDHOT_REACTOS; // Don't care, these hot keys are unrelated to the hot keys set by RegisterHotKey.
return 0; HotKeyItem->fsModifiers = fsModifiers;
} HotKeyItem->vk = vk;
HotKeyItem->Thread = pWnd->head.pti->pEThread; InsertHeadList(&gHotkeyList, &HotKeyItem->ListEntry);
HotKeyItem->hWnd = hWnd; }
HotKeyItem->id = IDHOT_REACTOS; // Don't care, these hot keys are unrelated to the hot keys set by RegisterHotKey. return Ret;
HotKeyItem->fsModifiers = fsModifiers;
HotKeyItem->vk = vk;
InsertHeadList (&gHotkeyList, &HotKeyItem->ListEntry);
}
return Ret;
} }
/* SYSCALLS *****************************************************************/ /* SYSCALLS *****************************************************************/
@ -288,88 +288,88 @@ NtUserRegisterHotKey(HWND hWnd,
UINT fsModifiers, UINT fsModifiers,
UINT vk) UINT vk)
{ {
PHOT_KEY_ITEM HotKeyItem; PHOT_KEY_ITEM HotKeyItem;
PWND Window; PWND Window;
PETHREAD HotKeyThread; PETHREAD HotKeyThread;
DECLARE_RETURN(BOOL); DECLARE_RETURN(BOOL);
TRACE("Enter NtUserRegisterHotKey\n"); TRACE("Enter NtUserRegisterHotKey\n");
UserEnterExclusive(); UserEnterExclusive();
if (hWnd == NULL) if (hWnd == NULL)
{ {
HotKeyThread = PsGetCurrentThread(); HotKeyThread = PsGetCurrentThread();
} }
else else
{ {
if(!(Window = UserGetWindowObject(hWnd))) if(!(Window = UserGetWindowObject(hWnd)))
{ {
RETURN( FALSE); RETURN( FALSE);
} }
HotKeyThread = Window->head.pti->pEThread; HotKeyThread = Window->head.pti->pEThread;
} }
/* Check for existing hotkey */ /* Check for existing hotkey */
if (IsHotKey(fsModifiers, vk)) if (IsHotKey(fsModifiers, vk))
{ {
RETURN( FALSE); RETURN( FALSE);
} }
HotKeyItem = ExAllocatePoolWithTag(PagedPool, sizeof(HOT_KEY_ITEM), USERTAG_HOTKEY); HotKeyItem = ExAllocatePoolWithTag(PagedPool, sizeof(HOT_KEY_ITEM), USERTAG_HOTKEY);
if (HotKeyItem == NULL) if (HotKeyItem == NULL)
{ {
RETURN( FALSE); RETURN( FALSE);
} }
HotKeyItem->Thread = HotKeyThread; HotKeyItem->Thread = HotKeyThread;
HotKeyItem->hWnd = hWnd; HotKeyItem->hWnd = hWnd;
HotKeyItem->id = id; HotKeyItem->id = id;
HotKeyItem->fsModifiers = fsModifiers; HotKeyItem->fsModifiers = fsModifiers;
HotKeyItem->vk = vk; HotKeyItem->vk = vk;
InsertHeadList (&gHotkeyList, &HotKeyItem->ListEntry); InsertHeadList(&gHotkeyList, &HotKeyItem->ListEntry);
RETURN( TRUE); RETURN( TRUE);
CLEANUP: CLEANUP:
TRACE("Leave NtUserRegisterHotKey, ret=%i\n",_ret_); TRACE("Leave NtUserRegisterHotKey, ret=%i\n", _ret_);
UserLeave(); UserLeave();
END_CLEANUP; END_CLEANUP;
} }
BOOL APIENTRY BOOL APIENTRY
NtUserUnregisterHotKey(HWND hWnd, int id) NtUserUnregisterHotKey(HWND hWnd, int id)
{ {
PHOT_KEY_ITEM HotKeyItem; PHOT_KEY_ITEM HotKeyItem;
PWND Window; PWND Window;
DECLARE_RETURN(BOOL); DECLARE_RETURN(BOOL);
TRACE("Enter NtUserUnregisterHotKey\n"); TRACE("Enter NtUserUnregisterHotKey\n");
UserEnterExclusive(); UserEnterExclusive();
if(!(Window = UserGetWindowObject(hWnd))) if(!(Window = UserGetWindowObject(hWnd)))
{ {
RETURN( FALSE); RETURN( FALSE);
} }
LIST_FOR_EACH(HotKeyItem, &gHotkeyList, HOT_KEY_ITEM, ListEntry) LIST_FOR_EACH(HotKeyItem, &gHotkeyList, HOT_KEY_ITEM, ListEntry)
{ {
if (HotKeyItem->hWnd == hWnd && HotKeyItem->id == id) if (HotKeyItem->hWnd == hWnd && HotKeyItem->id == id)
{ {
RemoveEntryList (&HotKeyItem->ListEntry); RemoveEntryList(&HotKeyItem->ListEntry);
ExFreePoolWithTag(HotKeyItem, USERTAG_HOTKEY); ExFreePoolWithTag(HotKeyItem, USERTAG_HOTKEY);
RETURN( TRUE); RETURN( TRUE);
} }
} }
RETURN( FALSE); RETURN( FALSE);
CLEANUP: CLEANUP:
TRACE("Leave NtUserUnregisterHotKey, ret=%i\n",_ret_); TRACE("Leave NtUserUnregisterHotKey, ret=%i\n", _ret_);
UserLeave(); UserLeave();
END_CLEANUP; END_CLEANUP;
} }
/* EOF */ /* EOF */