Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-05 12:15:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

[WIN32K]

Browse source 
- Mouse code cleanup
- Support MOUSEEVENTF_VIRTUALDESK flag in MOUSEINPUT properly
- Support MOUSE_VIRTUAL_DESKTOP flag in MOUSE_INPUT_DATA properly
- Do not ignore MK_SHIFT and MK_CONTROL flags in some mouse messages

svn path=/trunk/; revision=54227
This commit is contained in:
Rafal Harabien 2011-10-21 21:23:51 +00:00
parent 2ca62c7af9
commit 9e2f17bd8e
10 changed files with 295 additions and 277 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
reactos/include/psdk/winuser.h
View file

@ -1139,17 +1139,18 @@ extern "C" {
#define MSGF_MAINLOOP 8 #define MSGF_MAINLOOP 8
#define MSGF_USER 4096 #define MSGF_USER 4096
#define MSGF_MAX 8 #define MSGF_MAX 8
#define MOUSEEVENTF_MOVE 1 #define MOUSEEVENTF_MOVE 0x0001
#define MOUSEEVENTF_LEFTDOWN 2 #define MOUSEEVENTF_LEFTDOWN 0x0002
#define MOUSEEVENTF_LEFTUP 4 #define MOUSEEVENTF_LEFTUP 0x0004
#define MOUSEEVENTF_RIGHTDOWN 8 #define MOUSEEVENTF_RIGHTDOWN 0x0008
#define MOUSEEVENTF_RIGHTUP 16 #define MOUSEEVENTF_RIGHTUP 0x0010
#define MOUSEEVENTF_MIDDLEDOWN 32 #define MOUSEEVENTF_MIDDLEDOWN 0x0020
#define MOUSEEVENTF_MIDDLEUP 64 #define MOUSEEVENTF_MIDDLEUP 0x0040
#define MOUSEEVENTF_XDOWN 128 #define MOUSEEVENTF_XDOWN 0x0080
#define MOUSEEVENTF_XUP 256 #define MOUSEEVENTF_XUP 0x0100
#define MOUSEEVENTF_WHEEL 0x0800 #define MOUSEEVENTF_WHEEL 0x0800
#define MOUSEEVENTF_ABSOLUTE 32768 #define MOUSEEVENTF_VIRTUALDESK 0x4000
#define MOUSEEVENTF_ABSOLUTE 0x8000
#define PM_NOREMOVE 0 #define PM_NOREMOVE 0
#define PM_REMOVE 1 #define PM_REMOVE 1
#define PM_NOYIELD 2 #define PM_NOYIELD 2

22
reactos/subsystems/win32/win32k/include/input.h
View file

@ -58,23 +58,27 @@ extern PATTACHINFO gpai;
/* lParam bits */ /* lParam bits */
#define LP_DO_NOT_CARE_BIT (1<<25) // for GetKeyNameText #define LP_DO_NOT_CARE_BIT (1<<25) // for GetKeyNameText
/* General */
INIT_FUNCTION NTSTATUS NTAPI InitInputImpl(VOID); INIT_FUNCTION NTSTATUS NTAPI InitInputImpl(VOID);
BOOL FASTCALL IntBlockInput(PTHREADINFO W32Thread, BOOL BlockIt);
DWORD NTAPI CreateSystemThreads(UINT Type);
BOOL FASTCALL UserAttachThreadInput(PTHREADINFO,PTHREADINFO,BOOL);
VOID FASTCALL DoTheScreenSaver(VOID);
#define ThreadHasInputAccess(W32Thread) (TRUE)
/* Keyboard */
INIT_FUNCTION NTSTATUS NTAPI InitKeyboardImpl(VOID); INIT_FUNCTION NTSTATUS NTAPI InitKeyboardImpl(VOID);
VOID NTAPI UserInitKeyboard(HANDLE hKeyboardDevice); VOID NTAPI UserInitKeyboard(HANDLE hKeyboardDevice);
PKL W32kGetDefaultKeyLayout(VOID); PKL W32kGetDefaultKeyLayout(VOID);
VOID NTAPI UserProcessKeyboardInput(PKEYBOARD_INPUT_DATA pKeyInput); VOID NTAPI UserProcessKeyboardInput(PKEYBOARD_INPUT_DATA pKeyInput);
BOOL NTAPI UserSendKeyboardInput(KEYBDINPUT *pKbdInput, BOOL bInjected); BOOL NTAPI UserSendKeyboardInput(KEYBDINPUT *pKbdInput, BOOL bInjected);
VOID NTAPI UserProcessMouseInput(PMOUSE_INPUT_DATA Data, ULONG InputCount);
BOOL FASTCALL IntBlockInput(PTHREADINFO W32Thread, BOOL BlockIt);
BOOL FASTCALL IntMouseInput(MOUSEINPUT *mi, BOOL Injected);
PKL NTAPI UserHklToKbl(HKL hKl); PKL NTAPI UserHklToKbl(HKL hKl);
BOOL NTAPI UserSetDefaultInputLang(HKL hKl); BOOL NTAPI UserSetDefaultInputLang(HKL hKl);
VOID NTAPI KeyboardThreadMain(PVOID StartContext);
DWORD NTAPI CreateSystemThreads(UINT Type); /* Mouse */
BOOL FASTCALL UserAttachThreadInput(PTHREADINFO,PTHREADINFO,BOOL); WORD FASTCALL UserGetMouseButtonsState(VOID);
VOID FASTCALL DoTheScreenSaver(VOID); VOID NTAPI UserProcessMouseInput(PMOUSE_INPUT_DATA pMouseInputData);
#define ThreadHasInputAccess(W32Thread) (TRUE) BOOL NTAPI UserSendMouseInput(MOUSEINPUT *pMouseInput, BOOL bInjected);
extern HANDLE ghKeyboardDevice; extern HANDLE ghKeyboardDevice;
extern PTHREADINFO ptiRawInput; extern PTHREADINFO ptiRawInput;

2
reactos/subsystems/win32/win32k/ntuser/cursoricon.c
View file

@ -116,7 +116,7 @@ BOOL UserSetCursorPos( INT x, INT y, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Ho
/* 1. Generate a mouse move message, this sets the htEx and Track Window too. */ /* 1. Generate a mouse move message, this sets the htEx and Track Window too. */
Msg.message = WM_MOUSEMOVE; Msg.message = WM_MOUSEMOVE;
Msg.wParam = CurInfo->ButtonsDown; Msg.wParam = UserGetMouseButtonsState();
Msg.lParam = MAKELPARAM(x, y); Msg.lParam = MAKELPARAM(x, y);
Msg.pt = pt; Msg.pt = pt;
co_MsqInsertMouseMessage(&Msg, flags, dwExtraInfo, Hook); co_MsqInsertMouseMessage(&Msg, flags, dwExtraInfo, Hook);

4
reactos/subsystems/win32/win32k/ntuser/focus.c
View file

@ -581,8 +581,8 @@ co_UserSetCapture(HWND hWnd)
mi.mouseData = 0; mi.mouseData = 0;
mi.dwFlags = MOUSEEVENTF_MOVE; mi.dwFlags = MOUSEEVENTF_MOVE;
mi.time = 0; mi.time = 0;
mi.dwExtraInfo = 0; mi.dwExtraInfo = 0;
IntMouseInput(&mi,FALSE); UserSendMouseInput(&mi, FALSE);
} }
return hWndPrev; return hWndPrev;
} }

4
reactos/subsystems/win32/win32k/ntuser/input.c
View file

@ -261,7 +261,7 @@ RawInputThreadMain()
/* Process data */ /* Process data */
UserEnterExclusive(); UserEnterExclusive();
UserProcessMouseInput(&MouseInput, MouIosb.Information / sizeof(MOUSE_INPUT_DATA)); UserProcessMouseInput(&MouseInput);
UserLeave(); UserLeave();
} }
else if (MouStatus != STATUS_PENDING) else if (MouStatus != STATUS_PENDING)
@ -513,7 +513,7 @@ NtUserSendInput(
switch (SafeInput.type) switch (SafeInput.type)
{ {
case INPUT_MOUSE: case INPUT_MOUSE:
if (IntMouseInput(&SafeInput.mi, TRUE)) if (UserSendMouseInput(&SafeInput.mi, TRUE))
uRet++; uRet++;
break; break;
case INPUT_KEYBOARD: case INPUT_KEYBOARD:

28
reactos/subsystems/win32/win32k/ntuser/keyboard.c
View file

@ -1502,32 +1502,4 @@ Exit:
return Ret; return Ret;
} }
/*
* UserGetMouseButtonsState
*
* Returns bitfield used in mouse messages
*/
WORD FASTCALL
UserGetMouseButtonsState(VOID)
{
WORD wRet = 0;
if (gpsi->aiSysMet[SM_SWAPBUTTON])
{
if (IS_KEY_DOWN(gafAsyncKeyState, VK_RBUTTON)) wRet |= MK_LBUTTON;
if (IS_KEY_DOWN(gafAsyncKeyState, VK_LBUTTON)) wRet |= MK_RBUTTON;
}
else
{
if (IS_KEY_DOWN(gafAsyncKeyState, VK_LBUTTON)) wRet |= MK_LBUTTON;
if (IS_KEY_DOWN(gafAsyncKeyState, VK_RBUTTON)) wRet |= MK_RBUTTON;
}
if (IS_KEY_DOWN(gafAsyncKeyState, VK_MBUTTON)) wRet |= MK_MBUTTON;
if (IS_KEY_DOWN(gafAsyncKeyState, VK_SHIFT)) wRet |= MK_SHIFT;
if (IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL)) wRet |= MK_CONTROL;
if (IS_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON1)) wRet |= MK_XBUTTON1;
if (IS_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON2)) wRet |= MK_XBUTTON2;
return wRet;
}
/* EOF */ /* EOF */

483
reactos/subsystems/win32/win32k/ntuser/mouse.c
View file

@ -10,285 +10,331 @@
#include <win32k.h> #include <win32k.h>
DBG_DEFAULT_CHANNEL(UserInput); DBG_DEFAULT_CHANNEL(UserInput);
MOUSEMOVEPOINT MouseHistoryOfMoves[64]; MOUSEMOVEPOINT gMouseHistoryOfMoves[64];
INT gcur_count = 0; INT gcMouseHistoryOfMoves = 0;
#define ClearMouseInput(mi) \ /*
mi.dx = 0; \ * UserGetMouseButtonsState
mi.dy = 0; \ *
mi.mouseData = 0; \ * Returns bitfield of MK_* flags used in mouse messages
mi.dwFlags = 0; */
WORD FASTCALL
#define SendMouseEvent(mi) \ UserGetMouseButtonsState(VOID)
if(mi.dx != 0 || mi.dy != 0) \
mi.dwFlags |= MOUSEEVENTF_MOVE; \
if(mi.dwFlags) \
IntMouseInput(&mi,FALSE); \
ClearMouseInput(mi);
VOID NTAPI
UserProcessMouseInput(PMOUSE_INPUT_DATA Data, ULONG InputCount)
{ {
PMOUSE_INPUT_DATA mid; WORD wRet = 0;
MOUSEINPUT mi;
ULONG i;
ClearMouseInput(mi); wRet = IntGetSysCursorInfo()->ButtonsDown;
mi.time = 0;
mi.dwExtraInfo = 0;
for(i = 0; i < InputCount; i++)
{
mid = (Data + i);
mi.dx += mid->LastX;
mi.dy += mid->LastY;
/* Check if the mouse move is absolute */ if (IS_KEY_DOWN(gafAsyncKeyState, VK_SHIFT)) wRet |= MK_SHIFT;
if (mid->Flags == MOUSE_MOVE_ABSOLUTE) if (IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL)) wRet |= MK_CONTROL;
{
/* Set flag to convert to screen location */
mi.dwFlags |= MOUSEEVENTF_ABSOLUTE;
}
if(mid->ButtonFlags) return wRet;
{
if(mid->ButtonFlags & MOUSE_LEFT_BUTTON_DOWN)
{
mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;
SendMouseEvent(mi);
}
if(mid->ButtonFlags & MOUSE_LEFT_BUTTON_UP)
{
mi.dwFlags |= MOUSEEVENTF_LEFTUP;
SendMouseEvent(mi);
}
if(mid->ButtonFlags & MOUSE_MIDDLE_BUTTON_DOWN)
{
mi.dwFlags |= MOUSEEVENTF_MIDDLEDOWN;
SendMouseEvent(mi);
}
if(mid->ButtonFlags & MOUSE_MIDDLE_BUTTON_UP)
{
mi.dwFlags |= MOUSEEVENTF_MIDDLEUP;
SendMouseEvent(mi);
}
if(mid->ButtonFlags & MOUSE_RIGHT_BUTTON_DOWN)
{
mi.dwFlags |= MOUSEEVENTF_RIGHTDOWN;
SendMouseEvent(mi);
}
if(mid->ButtonFlags & MOUSE_RIGHT_BUTTON_UP)
{
mi.dwFlags |= MOUSEEVENTF_RIGHTUP;
SendMouseEvent(mi);
}
if(mid->ButtonFlags & MOUSE_BUTTON_4_DOWN)
{
mi.mouseData |= XBUTTON1;
mi.dwFlags |= MOUSEEVENTF_XDOWN;
SendMouseEvent(mi);
}
if(mid->ButtonFlags & MOUSE_BUTTON_4_UP)
{
mi.mouseData |= XBUTTON1;
mi.dwFlags |= MOUSEEVENTF_XUP;
SendMouseEvent(mi);
}
if(mid->ButtonFlags & MOUSE_BUTTON_5_DOWN)
{
mi.mouseData |= XBUTTON2;
mi.dwFlags |= MOUSEEVENTF_XDOWN;
SendMouseEvent(mi);
}
if(mid->ButtonFlags & MOUSE_BUTTON_5_UP)
{
mi.mouseData |= XBUTTON2;
mi.dwFlags |= MOUSEEVENTF_XUP;
SendMouseEvent(mi);
}
if(mid->ButtonFlags & MOUSE_WHEEL)
{
mi.mouseData = mid->ButtonData;
mi.dwFlags |= MOUSEEVENTF_WHEEL;
SendMouseEvent(mi);
}
}
}
SendMouseEvent(mi);
} }
BOOL FASTCALL /*
IntMouseInput(MOUSEINPUT *mi, BOOL Injected) * UserProcessMouseInput
*
* Process raw mouse input data
*/
VOID NTAPI
UserProcessMouseInput(PMOUSE_INPUT_DATA mid)
{ {
const UINT SwapBtnMsg[2][2] = MOUSEINPUT mi;
{
{WM_LBUTTONDOWN, WM_RBUTTONDOWN},
{WM_LBUTTONUP, WM_RBUTTONUP}
};
const WPARAM SwapBtn[2] =
{
MK_LBUTTON, MK_RBUTTON
};
POINT MousePos;
PSYSTEM_CURSORINFO CurInfo;
BOOL SwapButtons;
MSG Msg;
ASSERT(mi); /* Convert MOUSE_INPUT_DATA to MOUSEINPUT. First init all fields. */
mi.dx = mid->LastX;
mi.dy = mid->LastY;
mi.mouseData = 0;
mi.dwFlags = 0;
mi.time = 0;
mi.dwExtraInfo = mid->ExtraInformation;
CurInfo = IntGetSysCursorInfo(); /* Mouse position */
if (mi.dx != 0 || mi.dy != 0)
mi.dwFlags |= MOUSEEVENTF_MOVE;
if(!mi->time) /* Flags for absolute move */
if (mid->Flags & MOUSE_MOVE_ABSOLUTE)
mi.dwFlags |= MOUSEEVENTF_ABSOLUTE;
if (mid->Flags & MOUSE_VIRTUAL_DESKTOP)
mi.dwFlags |= MOUSEEVENTF_VIRTUALDESK;
/* Left button */
if (mid->ButtonFlags & MOUSE_LEFT_BUTTON_DOWN)
mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;
if (mid->ButtonFlags & MOUSE_LEFT_BUTTON_UP)
mi.dwFlags |= MOUSEEVENTF_LEFTUP;
/* Middle button */
if (mid->ButtonFlags & MOUSE_MIDDLE_BUTTON_DOWN)
mi.dwFlags |= MOUSEEVENTF_MIDDLEDOWN;
if (mid->ButtonFlags & MOUSE_MIDDLE_BUTTON_UP)
mi.dwFlags |= MOUSEEVENTF_MIDDLEUP;
/* Right button */
if (mid->ButtonFlags & MOUSE_RIGHT_BUTTON_DOWN)
mi.dwFlags |= MOUSEEVENTF_RIGHTDOWN;
if (mid->ButtonFlags & MOUSE_RIGHT_BUTTON_UP)
mi.dwFlags |= MOUSEEVENTF_RIGHTUP;
/* Note: next buttons use mouseData field so they cannot be sent in one call */
/* Button 4 */
if (mid->ButtonFlags & MOUSE_BUTTON_4_DOWN)
{ {
LARGE_INTEGER LargeTickCount; mi.dwFlags |= MOUSEEVENTF_XDOWN;
KeQueryTickCount(&LargeTickCount); mi.mouseData |= XBUTTON1;
mi->time = MsqCalculateMessageTime(&LargeTickCount); }
if (mid->ButtonFlags & MOUSE_BUTTON_4_UP)
{
mi.dwFlags |= MOUSEEVENTF_XUP;
mi.mouseData |= XBUTTON1;
} }
SwapButtons = gspv.bMouseBtnSwap; /* If mouseData is used by button 4, send input and clear mi */
if (mi.dwFlags & (MOUSE_BUTTON_4_DOWN | MOUSE_BUTTON_4_UP))
MousePos = gpsi->ptCursor;
if(mi->dwFlags & MOUSEEVENTF_MOVE)
{ {
if(mi->dwFlags & MOUSEEVENTF_ABSOLUTE) UserSendMouseInput(&mi, FALSE);
RtlZeroMemory(&mi, sizeof(mi));
}
/* Button 5 */
if (mid->ButtonFlags & MOUSE_BUTTON_5_DOWN)
{
mi.mouseData |= XBUTTON2;
mi.dwFlags |= MOUSEEVENTF_XDOWN;
}
if (mid->ButtonFlags & MOUSE_BUTTON_5_UP)
{
mi.mouseData |= XBUTTON2;
mi.dwFlags |= MOUSEEVENTF_XUP;
}
/* If mouseData is used by button 5, send input and clear mi */
if (mi.dwFlags & (MOUSE_BUTTON_5_DOWN | MOUSE_BUTTON_5_UP))
{
UserSendMouseInput(&mi, FALSE);
RtlZeroMemory(&mi, sizeof(mi));
}
/* Mouse wheel */
if (mid->ButtonFlags & MOUSE_WHEEL)
{
mi.mouseData = mid->ButtonData;
mi.dwFlags |= MOUSEEVENTF_WHEEL;
}
/* If something has changed, send input to user */
if (mi.dwFlags)
UserSendMouseInput(&mi, FALSE);
}
/*
* IntFixMouseInputButtons
*
* Helper function for supporting mouse button swap function
*/
DWORD
IntFixMouseInputButtons(DWORD dwFlags)
{
DWORD dwNewFlags;
if (!gspv.bMouseBtnSwap)
return dwFlags;
/* Buttons other than left and right are not affected */
dwNewFlags = dwFlags & ~(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP |
MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP);
/* Swap buttons */
if (dwFlags & MOUSEEVENTF_LEFTDOWN)
dwNewFlags |= MOUSEEVENTF_RIGHTDOWN;
if (dwFlags & MOUSEEVENTF_LEFTUP)
dwNewFlags |= MOUSEEVENTF_RIGHTUP;
if (dwFlags & MOUSEEVENTF_RIGHTDOWN)
dwNewFlags |= MOUSEEVENTF_LEFTDOWN;
if (dwFlags & MOUSEEVENTF_RIGHTUP)
dwNewFlags |= MOUSEEVENTF_LEFTUP;
return dwNewFlags;
}
/*
* UserSendMouseInput
*
* Process mouse input from input devices and SendInput API
*/
BOOL NTAPI
UserSendMouseInput(MOUSEINPUT *pmi, BOOL bInjected)
{
POINT ptCursor;
PSYSTEM_CURSORINFO pCurInfo;
MSG Msg;
DWORD dwFlags;
ASSERT(pmi);
pCurInfo = IntGetSysCursorInfo();
ptCursor = gpsi->ptCursor;
dwFlags = IntFixMouseInputButtons(pmi->dwFlags);
if (pmi->dwFlags & MOUSEEVENTF_MOVE)
{
/* Mouse has changes position */
if (!(pmi->dwFlags & MOUSEEVENTF_ABSOLUTE))
{ {
MousePos.x = mi->dx * UserGetSystemMetrics(SM_CXVIRTUALSCREEN) >> 16; /* Relative move */
MousePos.y = mi->dy * UserGetSystemMetrics(SM_CYVIRTUALSCREEN) >> 16; ptCursor.x += pmi->dx;
ptCursor.y += pmi->dy;
}
else if (pmi->dwFlags & MOUSEEVENTF_VIRTUALDESK)
{
/* Absolute move in virtual screen units */
ptCursor.x = pmi->dx * UserGetSystemMetrics(SM_CXVIRTUALSCREEN) >> 16;
ptCursor.y = pmi->dy * UserGetSystemMetrics(SM_CYVIRTUALSCREEN) >> 16;
} }
else else
{ {
MousePos.x += mi->dx; /* Absolute move in primary monitor units */
MousePos.y += mi->dy; ptCursor.x = pmi->dx * UserGetSystemMetrics(SM_CXSCREEN) >> 16;
ptCursor.y = pmi->dy * UserGetSystemMetrics(SM_CYSCREEN) >> 16;
} }
} }
/* Init message fields */
Msg.wParam = UserGetMouseButtonsState();
Msg.lParam = MAKELPARAM(ptCursor.x, ptCursor.y);
Msg.pt = ptCursor;
Msg.time = pmi->time;
if (!Msg.time)
{
LARGE_INTEGER LargeTickCount;
KeQueryTickCount(&LargeTickCount);
Msg.time = MsqCalculateMessageTime(&LargeTickCount);
}
/* Do GetMouseMovePointsEx FIFO. */ /* Do GetMouseMovePointsEx FIFO. */
MouseHistoryOfMoves[gcur_count].x = MousePos.x; gMouseHistoryOfMoves[gcMouseHistoryOfMoves].x = ptCursor.x;
MouseHistoryOfMoves[gcur_count].y = MousePos.y; gMouseHistoryOfMoves[gcMouseHistoryOfMoves].y = ptCursor.y;
MouseHistoryOfMoves[gcur_count].time = mi->time; gMouseHistoryOfMoves[gcMouseHistoryOfMoves].time = Msg.time;
MouseHistoryOfMoves[gcur_count].dwExtraInfo = mi->dwExtraInfo; gMouseHistoryOfMoves[gcMouseHistoryOfMoves].dwExtraInfo = pmi->dwExtraInfo;
if (++gcur_count == ARRAYSIZE(MouseHistoryOfMoves)) if (++gcMouseHistoryOfMoves == ARRAYSIZE(gMouseHistoryOfMoves))
gcur_count = 0; // 0 - 63 is 64, FIFO forwards. gcMouseHistoryOfMoves = 0; // 0 - 63 is 64, FIFO forwards.
/* /* Update cursor position */
* Insert the messages into the system queue if (dwFlags & MOUSEEVENTF_MOVE)
*/
Msg.wParam = 0;
Msg.lParam = MAKELPARAM(MousePos.x, MousePos.y);
Msg.pt = MousePos;
if (IS_KEY_DOWN(gafAsyncKeyState, VK_SHIFT))
{ {
Msg.wParam |= MK_SHIFT; UserSetCursorPos(ptCursor.x, ptCursor.y, bInjected, pmi->dwExtraInfo, TRUE);
} }
if (IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL)) /* Left button */
{ if (dwFlags & MOUSEEVENTF_LEFTDOWN)
Msg.wParam |= MK_CONTROL;
}
if(mi->dwFlags & MOUSEEVENTF_MOVE)
{
UserSetCursorPos(MousePos.x, MousePos.y, Injected, mi->dwExtraInfo, TRUE);
}
if(mi->dwFlags & MOUSEEVENTF_LEFTDOWN)
{ {
SET_KEY_DOWN(gafAsyncKeyState, VK_LBUTTON, TRUE); SET_KEY_DOWN(gafAsyncKeyState, VK_LBUTTON, TRUE);
Msg.message = SwapBtnMsg[0][SwapButtons]; Msg.message = WM_LBUTTONDOWN;
CurInfo->ButtonsDown |= SwapBtn[SwapButtons]; pCurInfo->ButtonsDown |= MK_LBUTTON;
Msg.wParam |= CurInfo->ButtonsDown; Msg.wParam |= MK_LBUTTON;
co_MsqInsertMouseMessage(&Msg, Injected, mi->dwExtraInfo, TRUE); co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
} }
else if(mi->dwFlags & MOUSEEVENTF_LEFTUP) else if (dwFlags & MOUSEEVENTF_LEFTUP)
{ {
SET_KEY_DOWN(gafAsyncKeyState, VK_LBUTTON, FALSE); SET_KEY_DOWN(gafAsyncKeyState, VK_LBUTTON, FALSE);
Msg.message = SwapBtnMsg[1][SwapButtons]; Msg.message = WM_LBUTTONUP;
CurInfo->ButtonsDown &= ~SwapBtn[SwapButtons]; pCurInfo->ButtonsDown &= ~MK_LBUTTON;
Msg.wParam |= CurInfo->ButtonsDown; Msg.wParam &= ~MK_LBUTTON;
co_MsqInsertMouseMessage(&Msg, Injected, mi->dwExtraInfo, TRUE); co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
} }
if(mi->dwFlags & MOUSEEVENTF_MIDDLEDOWN)
/* Middle button */
if (dwFlags & MOUSEEVENTF_MIDDLEDOWN)
{ {
SET_KEY_DOWN(gafAsyncKeyState, VK_MBUTTON, TRUE); SET_KEY_DOWN(gafAsyncKeyState, VK_MBUTTON, TRUE);
Msg.message = WM_MBUTTONDOWN; Msg.message = WM_MBUTTONDOWN;
CurInfo->ButtonsDown |= MK_MBUTTON; pCurInfo->ButtonsDown |= MK_MBUTTON;
Msg.wParam |= CurInfo->ButtonsDown; Msg.wParam |= MK_MBUTTON;
co_MsqInsertMouseMessage(&Msg, Injected, mi->dwExtraInfo, TRUE); co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
} }
else if(mi->dwFlags & MOUSEEVENTF_MIDDLEUP) else if (dwFlags & MOUSEEVENTF_MIDDLEUP)
{ {
SET_KEY_DOWN(gafAsyncKeyState, VK_MBUTTON, FALSE); SET_KEY_DOWN(gafAsyncKeyState, VK_MBUTTON, FALSE);
Msg.message = WM_MBUTTONUP; Msg.message = WM_MBUTTONUP;
CurInfo->ButtonsDown &= ~MK_MBUTTON; pCurInfo->ButtonsDown &= ~MK_MBUTTON;
Msg.wParam |= CurInfo->ButtonsDown; Msg.wParam &= ~MK_MBUTTON;
co_MsqInsertMouseMessage(&Msg, Injected, mi->dwExtraInfo, TRUE); co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
}
if(mi->dwFlags & MOUSEEVENTF_RIGHTDOWN)
{
SET_KEY_DOWN(gafAsyncKeyState, VK_RBUTTON, TRUE);
Msg.message = SwapBtnMsg[0][!SwapButtons];
CurInfo->ButtonsDown |= SwapBtn[!SwapButtons];
Msg.wParam |= CurInfo->ButtonsDown;
co_MsqInsertMouseMessage(&Msg, Injected, mi->dwExtraInfo, TRUE);
}
else if(mi->dwFlags & MOUSEEVENTF_RIGHTUP)
{
SET_KEY_DOWN(gafAsyncKeyState, VK_RBUTTON, FALSE);
Msg.message = SwapBtnMsg[1][!SwapButtons];
CurInfo->ButtonsDown &= ~SwapBtn[!SwapButtons];
Msg.wParam |= CurInfo->ButtonsDown;
co_MsqInsertMouseMessage(&Msg, Injected, mi->dwExtraInfo, TRUE);
} }
if((mi->dwFlags & (MOUSEEVENTF_XDOWN | MOUSEEVENTF_XUP)) && /* Right button */
(mi->dwFlags & MOUSEEVENTF_WHEEL)) if (dwFlags & MOUSEEVENTF_RIGHTDOWN)
{ {
/* fail because both types of events use the mouseData field */ SET_KEY_DOWN(gafAsyncKeyState, VK_RBUTTON, TRUE);
Msg.message = WM_RBUTTONDOWN;
pCurInfo->ButtonsDown |= MK_RBUTTON;
Msg.wParam |= MK_RBUTTON;
co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
}
else if (dwFlags & MOUSEEVENTF_RIGHTUP)
{
SET_KEY_DOWN(gafAsyncKeyState, VK_RBUTTON, FALSE);
Msg.message = WM_RBUTTONUP;
pCurInfo->ButtonsDown &= ~MK_RBUTTON;
Msg.wParam &= ~MK_RBUTTON;
co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
}
if((dwFlags & (MOUSEEVENTF_XDOWN | MOUSEEVENTF_XUP)) &&
(dwFlags & MOUSEEVENTF_WHEEL))
{
/* Fail because both types of events use the mouseData field */
WARN("Invalid flags!\n");
return FALSE; return FALSE;
} }
if(mi->dwFlags & MOUSEEVENTF_XDOWN) /* X-Button (4 or 5) */
if (dwFlags & MOUSEEVENTF_XDOWN)
{ {
Msg.message = WM_XBUTTONDOWN; Msg.message = WM_XBUTTONDOWN;
if(mi->mouseData & XBUTTON1) if (pmi->mouseData & XBUTTON1)
{ {
SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON1, TRUE); SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON1, TRUE);
CurInfo->ButtonsDown |= MK_XBUTTON1; pCurInfo->ButtonsDown |= MK_XBUTTON1;
Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON1); Msg.wParam |= MAKEWPARAM(MK_XBUTTON1, XBUTTON1);
co_MsqInsertMouseMessage(&Msg, Injected, mi->dwExtraInfo, TRUE); co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
} }
if(mi->mouseData & XBUTTON2) if (pmi->mouseData & XBUTTON2)
{ {
SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON2, TRUE); SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON2, TRUE);
CurInfo->ButtonsDown |= MK_XBUTTON2; pCurInfo->ButtonsDown |= MK_XBUTTON2;
Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON2); Msg.wParam |= MAKEWPARAM(MK_XBUTTON2, XBUTTON2);
co_MsqInsertMouseMessage(&Msg, Injected, mi->dwExtraInfo, TRUE); co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
} }
} }
else if(mi->dwFlags & MOUSEEVENTF_XUP) else if (dwFlags & MOUSEEVENTF_XUP)
{ {
Msg.message = WM_XBUTTONUP; Msg.message = WM_XBUTTONUP;
if(mi->mouseData & XBUTTON1) if(pmi->mouseData & XBUTTON1)
{ {
SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON1, FALSE); SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON1, FALSE);
CurInfo->ButtonsDown &= ~MK_XBUTTON1; pCurInfo->ButtonsDown &= ~MK_XBUTTON1;
Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON1); Msg.wParam &= ~MK_XBUTTON1;
co_MsqInsertMouseMessage(&Msg, Injected, mi->dwExtraInfo, TRUE); Msg.wParam |= MAKEWPARAM(0, XBUTTON2);
co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
} }
if(mi->mouseData & XBUTTON2) if (pmi->mouseData & XBUTTON2)
{ {
SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON2, FALSE); SET_KEY_DOWN(gafAsyncKeyState, VK_XBUTTON2, FALSE);
CurInfo->ButtonsDown &= ~MK_XBUTTON2; pCurInfo->ButtonsDown &= ~MK_XBUTTON2;
Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON2); Msg.wParam &= ~MK_XBUTTON2;
co_MsqInsertMouseMessage(&Msg, Injected, mi->dwExtraInfo, TRUE); Msg.wParam |= MAKEWPARAM(0, XBUTTON2);
co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
} }
} }
if(mi->dwFlags & MOUSEEVENTF_WHEEL)
/* Mouse wheel */
if (dwFlags & MOUSEEVENTF_WHEEL)
{ {
Msg.message = WM_MOUSEWHEEL; Msg.message = WM_MOUSEWHEEL;
Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, mi->mouseData); Msg.wParam = MAKEWPARAM(pCurInfo->ButtonsDown, pmi->mouseData);
co_MsqInsertMouseMessage(&Msg, Injected, mi->dwExtraInfo, TRUE); co_MsqInsertMouseMessage(&Msg, bInjected, pmi->dwExtraInfo, TRUE);
} }
return TRUE; return TRUE;
@ -462,9 +508,6 @@ NtUserTrackMouseEvent(
return bRet; return bRet;
} }
extern MOUSEMOVEPOINT MouseHistoryOfMoves[];
extern INT gcur_count;
DWORD DWORD
APIENTRY APIENTRY
NtUserGetMouseMovePointsEx( NtUserGetMouseMovePointsEx(
@ -508,18 +551,18 @@ NtUserGetMouseMovePointsEx(
// http://msdn.microsoft.com/en-us/library/ms646259(v=vs.85).aspx // http://msdn.microsoft.com/en-us/library/ms646259(v=vs.85).aspx
// This explains the math issues in transforming points. // This explains the math issues in transforming points.
iRet = gcur_count; // FIFO is forward so retrieve backward. iRet = gcMouseHistoryOfMoves; // FIFO is forward so retrieve backward.
//Hit = FALSE; //Hit = FALSE;
do do
{ {
if (Safeppt.x == 0 && Safeppt.y == 0) if (Safeppt.x == 0 && Safeppt.y == 0)
break; // No test. break; // No test.
// Finds the point, it returns the last nBufPoints prior to and including the supplied point. // Finds the point, it returns the last nBufPoints prior to and including the supplied point.
if (MouseHistoryOfMoves[iRet].x == Safeppt.x && MouseHistoryOfMoves[iRet].y == Safeppt.y) if (gMouseHistoryOfMoves[iRet].x == Safeppt.x && gMouseHistoryOfMoves[iRet].y == Safeppt.y)
{ {
if (Safeppt.time) // Now test time and it seems to be absolute. if (Safeppt.time) // Now test time and it seems to be absolute.
{ {
if (Safeppt.time == MouseHistoryOfMoves[iRet].time) if (Safeppt.time == gMouseHistoryOfMoves[iRet].time)
{ {
//Hit = TRUE; //Hit = TRUE;
break; break;
@ -535,7 +578,7 @@ NtUserGetMouseMovePointsEx(
} }
if (--iRet < 0) iRet = 63; if (--iRet < 0) iRet = 63;
} }
while (iRet != gcur_count); while (iRet != gcMouseHistoryOfMoves);
switch(resolution) switch(resolution)
{ {

2
reactos/subsystems/win32/win32k/ntuser/timer.c
View file

@ -11,8 +11,6 @@
#include <win32k.h> #include <win32k.h>
DBG_DEFAULT_CHANNEL(UserTimer); DBG_DEFAULT_CHANNEL(UserTimer);
WORD FASTCALL UserGetMouseButtonsState(VOID);
/* GLOBALS *******************************************************************/ /* GLOBALS *******************************************************************/
static LIST_ENTRY TimersListHead; static LIST_ENTRY TimersListHead;

2
reactos/subsystems/win32/win32k/ntuser/window.c
View file

@ -2506,7 +2506,7 @@ BOOLEAN FASTCALL co_UserDestroyWindow(PWND Window)
/* Generate mouse move message for the next window */ /* Generate mouse move message for the next window */
msg.message = WM_MOUSEMOVE; msg.message = WM_MOUSEMOVE;
msg.wParam = IntGetSysCursorInfo()->ButtonsDown; msg.wParam = UserGetMouseButtonsState();
msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y); msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
msg.pt = gpsi->ptCursor; msg.pt = gpsi->ptCursor;
co_MsqInsertMouseMessage(&msg, 0, 0, TRUE); co_MsqInsertMouseMessage(&msg, 0, 0, TRUE);

2
reactos/subsystems/win32/win32k/ntuser/winpos.c
View file

@ -1317,7 +1317,7 @@ co_WinPosSetWindowPos(
/* Generate mouse move message */ /* Generate mouse move message */
MSG msg; MSG msg;
msg.message = WM_MOUSEMOVE; msg.message = WM_MOUSEMOVE;
msg.wParam = IntGetSysCursorInfo()->ButtonsDown; msg.wParam = UserGetMouseButtonsState();
msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y); msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
msg.pt = gpsi->ptCursor; msg.pt = gpsi->ptCursor;
co_MsqInsertMouseMessage(&msg, 0, 0, TRUE); co_MsqInsertMouseMessage(&msg, 0, 0, TRUE);