system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-31 12:19:49 +00:00
Code Issues Projects Releases Packages Wiki Activity

Moved SendInput and related functions to the USER driver to avoid a

Browse source 
number of dll separation hacks.
This commit is contained in:
Alexandre Julliard 2005-03-09 16:45:23 +00:00
parent 6bd194d2fd
commit aef19abc82
10 changed files with 700 additions and 708 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
dlls/user/user_main.c
View file

@ -83,19 +83,19 @@ static BOOL load_driver(void)
ExitProcess(1);
}
GET_USER_FUNC(InitKeyboard);
GET_USER_FUNC(VkKeyScanEx);
GET_USER_FUNC(MapVirtualKeyEx);
GET_USER_FUNC(ActivateKeyboardLayout);
GET_USER_FUNC(Beep);
GET_USER_FUNC(GetAsyncKeyState);
GET_USER_FUNC(GetKeyNameText);
GET_USER_FUNC(ToUnicodeEx);
GET_USER_FUNC(GetKeyboardLayoutList);
GET_USER_FUNC(GetKeyboardLayout);
GET_USER_FUNC(GetKeyboardLayoutList);
GET_USER_FUNC(GetKeyboardLayoutName);
GET_USER_FUNC(LoadKeyboardLayout);
GET_USER_FUNC(ActivateKeyboardLayout);
GET_USER_FUNC(MapVirtualKeyEx);
GET_USER_FUNC(SendInput);
GET_USER_FUNC(ToUnicodeEx);
GET_USER_FUNC(UnloadKeyboardLayout);
GET_USER_FUNC(Beep);
GET_USER_FUNC(InitMouse);
GET_USER_FUNC(VkKeyScanEx);
GET_USER_FUNC(SetCursor);
GET_USER_FUNC(GetCursorPos);
GET_USER_FUNC(SetCursorPos);
@ -244,12 +244,6 @@ static BOOL process_attach(void)
/* Create desktop window */
if (!WIN_CreateDesktopWindow()) return FALSE;
/* Initialize keyboard driver */
if (USER_Driver.pInitKeyboard) USER_Driver.pInitKeyboard( InputKeyStateTable );
/* Initialize mouse driver */
if (USER_Driver.pInitMouse) USER_Driver.pInitMouse( InputKeyStateTable );
return TRUE;
}

22
dlls/user/user_private.h
View file

@ -62,23 +62,23 @@ struct tagCURSORICONINFO;
typedef struct tagUSER_DRIVER {
/* keyboard functions */
void (*pInitKeyboard)(LPBYTE);
SHORT (*pVkKeyScanEx)(WCHAR, HKL);
UINT (*pMapVirtualKeyEx)(UINT, UINT, HKL);
HKL (*pActivateKeyboardLayout)(HKL, UINT);
void (*pBeep)(void);
SHORT (*pGetAsyncKeyState)(INT);
INT (*pGetKeyNameText)(LONG, LPWSTR, INT);
INT (*pToUnicodeEx)(UINT, UINT, LPBYTE, LPWSTR, int, UINT, HKL);
UINT (*pGetKeyboardLayoutList)(INT, HKL *);
HKL (*pGetKeyboardLayout)(DWORD);
UINT (*pGetKeyboardLayoutList)(INT, HKL *);
BOOL (*pGetKeyboardLayoutName)(LPWSTR);
HKL (*pLoadKeyboardLayout)(LPCWSTR, UINT);
HKL (*pActivateKeyboardLayout)(HKL, UINT);
UINT (*pMapVirtualKeyEx)(UINT, UINT, HKL);
UINT (*pSendInput)(UINT, LPINPUT, int);
INT (*pToUnicodeEx)(UINT, UINT, LPBYTE, LPWSTR, int, UINT, HKL);
BOOL (*pUnloadKeyboardLayout)(HKL);
void (*pBeep)(void);
SHORT (*pVkKeyScanEx)(WCHAR, HKL);
/* mouse functions */
void (*pInitMouse)(LPBYTE);
void (*pSetCursor)(struct tagCURSORICONINFO *);
void (*pGetCursorPos)(LPPOINT);
void (*pSetCursorPos)(INT,INT);
BOOL (*pGetCursorPos)(LPPOINT);
BOOL (*pSetCursorPos)(INT,INT);
/* screen saver functions */
BOOL (*pGetScreenSaveActive)(void);
void (*pSetScreenSaveActive)(BOOL);
@ -119,8 +119,6 @@ typedef struct tagUSER_DRIVER {
extern USER_DRIVER USER_Driver;
extern HMODULE user32_module;
extern BYTE InputKeyStateTable[256];
extern BYTE AsyncKeyStateTable[256];
extern DWORD USER16_AlertableWait;
extern BOOL CLIPBOARD_ReleaseOwner(void);

29
dlls/x11drv/event.c
View file

@ -951,3 +951,32 @@ LRESULT X11DRV_WindowMessage( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
return 0;
}
}
/***********************************************************************
* X11DRV_SendInput (X11DRV.@)
*/
UINT X11DRV_SendInput( UINT count, LPINPUT inputs, int size )
{
UINT i;
for (i = 0; i < count; i++, inputs++)
{
switch(inputs->type)
{
case INPUT_MOUSE:
X11DRV_send_mouse_input( 0, inputs->u.mi.dwFlags, inputs->u.mi.dx, inputs->u.mi.dy,
inputs->u.mi.mouseData, inputs->u.mi.time,
inputs->u.mi.dwExtraInfo, LLMHF_INJECTED );
break;
case INPUT_KEYBOARD:
X11DRV_send_keyboard_input( inputs->u.ki.wVk, inputs->u.ki.wScan, inputs->u.ki.dwFlags,
inputs->u.ki.time, inputs->u.ki.dwExtraInfo, LLKHF_INJECTED );
break;
case INPUT_HARDWARE:
FIXME( "INPUT_HARDWARE not supported\n" );
break;
}
}
return count;
}

176
dlls/x11drv/keyboard.c
View file

@ -48,17 +48,47 @@
#include "winnls.h"
#include "win.h"
#include "x11drv.h"
#include "wine/server.h"
#include "wine/unicode.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(keyboard);
WINE_DECLARE_DEBUG_CHANNEL(key);
WINE_DECLARE_DEBUG_CHANNEL(dinput);
typedef union
{
struct
{
#ifndef BITFIELDS_BIGENDIAN
unsigned long count : 16;
#endif
unsigned long code : 8;
unsigned long extended : 1;
unsigned long unused : 2;
unsigned long win_internal : 2;
unsigned long context : 1;
unsigned long previous : 1;
unsigned long transition : 1;
#ifdef BITFIELDS_BIGENDIAN
unsigned long count : 16;
#endif
} lp1;
unsigned long lp2;
} KEYLP;
/* key state table bits:
0x80 -> key is pressed
0x40 -> key got pressed since last time
0x01 -> key is toggled
*/
BYTE key_state_table[256];
static BYTE TrackSysKey = 0; /* determine whether ALT key up will cause a WM_SYSKEYUP
or a WM_KEYUP message */
static int min_keycode, max_keycode, keysyms_per_keycode;
static WORD keyc2vkey[256], keyc2scan[256];
static LPBYTE pKeyStateTable;
static int NumLockMask, AltGrMask; /* mask in the XKeyEvent state */
static int kcControl, kcAlt, kcShift, kcNumLock, kcCapsLock; /* keycodes */
@ -1005,19 +1035,85 @@ static BOOL NumState=FALSE, CapsState=FALSE;
/***********************************************************************
* send_keyboard_input
* X11DRV_send_keyboard_input
*/
static void send_keyboard_input( WORD wVk, WORD wScan, DWORD dwFlags, DWORD time )
void X11DRV_send_keyboard_input( WORD wVk, WORD wScan, DWORD dwFlags, DWORD time,
DWORD dwExtraInfo, UINT injected_flags )
{
INPUT input;
UINT message;
KEYLP keylp;
KBDLLHOOKSTRUCT hook;
input.type = WINE_INTERNAL_INPUT_KEYBOARD;
input.u.ki.wVk = wVk;
input.u.ki.wScan = wScan;
input.u.ki.dwFlags = dwFlags;
input.u.ki.time = time;
input.u.ki.dwExtraInfo = 0;
SendInput( 1, &input, sizeof(input) );
keylp.lp2 = 0;
keylp.lp1.count = 1;
keylp.lp1.code = wScan;
keylp.lp1.extended = (dwFlags & KEYEVENTF_EXTENDEDKEY) != 0;
keylp.lp1.win_internal = 0; /* this has something to do with dialogs,
* don't remember where I read it - AK */
/* it's '1' under windows, when a dialog box appears
* and you press one of the underlined keys - DF*/
/* note that there is a test for all this */
if (dwFlags & KEYEVENTF_KEYUP )
{
message = WM_KEYUP;
if ((key_state_table[VK_MENU] & 0x80) &&
((wVk == VK_MENU) || (wVk == VK_CONTROL) || !(key_state_table[VK_CONTROL] & 0x80)))
{
if( TrackSysKey == VK_MENU || /* <ALT>-down/<ALT>-up sequence */
(wVk != VK_MENU)) /* <ALT>-down...<something else>-up */
message = WM_SYSKEYUP;
TrackSysKey = 0;
}
key_state_table[wVk] &= ~0x80;
keylp.lp1.previous = 1;
keylp.lp1.transition = 1;
}
else
{
keylp.lp1.previous = (key_state_table[wVk] & 0x80) != 0;
keylp.lp1.transition = 0;
if (!(key_state_table[wVk] & 0x80)) key_state_table[wVk] ^= 0x01;
key_state_table[wVk] |= 0xc0;
message = WM_KEYDOWN;
if ((key_state_table[VK_MENU] & 0x80) && !(key_state_table[VK_CONTROL] & 0x80))
{
message = WM_SYSKEYDOWN;
TrackSysKey = wVk;
}
}
keylp.lp1.context = (key_state_table[VK_MENU] & 0x80) != 0; /* 1 if alt */
TRACE_(key)(" wParam=%04x, lParam=%08lx, InputKeyState=%x\n",
wVk, keylp.lp2, key_state_table[wVk] );
hook.vkCode = wVk;
hook.scanCode = wScan;
hook.flags = (keylp.lp2 >> 24) | injected_flags;
hook.time = time;
hook.dwExtraInfo = dwExtraInfo;
if (HOOK_CallHooks( WH_KEYBOARD_LL, HC_ACTION, message, (LPARAM)&hook, TRUE )) return;
SERVER_START_REQ( send_message )
{
req->id = GetCurrentThreadId();
req->type = MSG_HARDWARE;
req->flags = 0;
req->win = 0;
req->msg = message;
req->wparam = wVk;
req->lparam = keylp.lp2;
req->x = cursor_pos.x;
req->y = cursor_pos.y;
req->time = time;
req->info = dwExtraInfo;
req->timeout = -1;
req->callback = NULL;
wine_server_call( req );
}
SERVER_END_REQ;
}
@ -1039,30 +1135,31 @@ static void KEYBOARD_GenerateMsg( WORD vkey, WORD scan, int Evtype, DWORD event_
don't treat it. It's from the same key press. Then the state goes to ON.
And from there, a 'release' event will switch off the toggle key. */
*State=FALSE;
TRACE("INTERM : don\'t treat release of toggle key. InputKeyStateTable[%#x] = %#x\n",vkey,pKeyStateTable[vkey]);
TRACE("INTERM : don't treat release of toggle key. key_state_table[%#x] = %#x\n",
vkey,key_state_table[vkey]);
} else
{
down = (vkey==VK_NUMLOCK ? KEYEVENTF_EXTENDEDKEY : 0);
up = (vkey==VK_NUMLOCK ? KEYEVENTF_EXTENDEDKEY : 0) | KEYEVENTF_KEYUP;
if ( pKeyStateTable[vkey] & 0x1 ) /* it was ON */
if ( key_state_table[vkey] & 0x1 ) /* it was ON */
{
if (Evtype!=KeyPress)
{
TRACE("ON + KeyRelease => generating DOWN and UP messages.\n");
send_keyboard_input( vkey, scan, down, event_time );
send_keyboard_input( vkey, scan, up, event_time );
X11DRV_send_keyboard_input( vkey, scan, down, event_time, 0, 0 );
X11DRV_send_keyboard_input( vkey, scan, up, event_time, 0, 0 );
*State=FALSE;
pKeyStateTable[vkey] &= ~0x01; /* Toggle state to off. */
key_state_table[vkey] &= ~0x01; /* Toggle state to off. */
}
}
else /* it was OFF */
if (Evtype==KeyPress)
{
TRACE("OFF + Keypress => generating DOWN and UP messages.\n");
send_keyboard_input( vkey, scan, down, event_time );
send_keyboard_input( vkey, scan, up, event_time );
X11DRV_send_keyboard_input( vkey, scan, down, event_time, 0, 0 );
X11DRV_send_keyboard_input( vkey, scan, up, event_time, 0, 0 );
*State=TRUE; /* Goes to intermediary state before going to ON */
pKeyStateTable[vkey] |= 0x01; /* Toggle state to on. */
key_state_table[vkey] |= 0x01; /* Toggle state to on. */
}
}
}
@ -1076,15 +1173,15 @@ static void KEYBOARD_GenerateMsg( WORD vkey, WORD scan, int Evtype, DWORD event_
inline static void KEYBOARD_UpdateOneState ( int vkey, int state, DWORD time )
{
/* Do something if internal table state != X state for keycode */
if (((pKeyStateTable[vkey] & 0x80)!=0) != state)
if (((key_state_table[vkey] & 0x80)!=0) != state)
{
TRACE("Adjusting state for vkey %#.2x. State before %#.2x\n",
vkey, pKeyStateTable[vkey]);
vkey, key_state_table[vkey]);
/* Fake key being pressed inside wine */
send_keyboard_input( vkey, 0, state? 0 : KEYEVENTF_KEYUP, time );
X11DRV_send_keyboard_input( vkey, 0, state? 0 : KEYEVENTF_KEYUP, time, 0, 0 );
TRACE("State after %#.2x\n",pKeyStateTable[vkey]);
TRACE("State after %#.2x\n",key_state_table[vkey]);
}
}
@ -1213,20 +1310,20 @@ void X11DRV_KeyEvent( HWND hwnd, XEvent *xev )
KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, event->type, event_time );
break;
case VK_CAPITAL:
TRACE("Caps Lock event. (type %d). State before : %#.2x\n",event->type,pKeyStateTable[vkey]);
TRACE("Caps Lock event. (type %d). State before : %#.2x\n",event->type,key_state_table[vkey]);
KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, event->type, event_time );
TRACE("State after : %#.2x\n",pKeyStateTable[vkey]);
TRACE("State after : %#.2x\n",key_state_table[vkey]);
break;
default:
/* Adjust the NUMLOCK state if it has been changed outside wine */
if (!(pKeyStateTable[VK_NUMLOCK] & 0x01) != !(event->state & NumLockMask))
if (!(key_state_table[VK_NUMLOCK] & 0x01) != !(event->state & NumLockMask))
{
TRACE("Adjusting NumLock state.\n");
KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, KeyPress, event_time );
KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, KeyRelease, event_time );
}
/* Adjust the CAPSLOCK state if it has been changed outside wine */
if (!(pKeyStateTable[VK_CAPITAL] & 0x01) != !(event->state & LockMask))
if (!(key_state_table[VK_CAPITAL] & 0x01) != !(event->state & LockMask))
{
TRACE("Adjusting Caps Lock state.\n");
KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, KeyPress, event_time );
@ -1243,7 +1340,7 @@ void X11DRV_KeyEvent( HWND hwnd, XEvent *xev )
if ( event->type == KeyRelease ) dwFlags |= KEYEVENTF_KEYUP;
if ( vkey & 0x100 ) dwFlags |= KEYEVENTF_EXTENDEDKEY;
send_keyboard_input( vkey & 0xff, bScan, dwFlags, event_time );
X11DRV_send_keyboard_input( vkey & 0xff, bScan, dwFlags, event_time, 0, 0 );
}
}
}
@ -1359,9 +1456,9 @@ X11DRV_KEYBOARD_DetectLayout (void)
}
/**********************************************************************
* InitKeyboard (X11DRV.@)
* X11DRV_InitKeyboard
*/
void X11DRV_InitKeyboard( BYTE *key_state_table )
void X11DRV_InitKeyboard(void)
{
Display *display = thread_display();
KeySym *ksp;
@ -1374,8 +1471,6 @@ void X11DRV_InitKeyboard( BYTE *key_state_table )
char ckey[4]={0,0,0,0};
const char (*lkey)[MAIN_LEN][4];
pKeyStateTable = key_state_table;
wine_tsx11_lock();
XDisplayKeycodes(display, &min_keycode, &max_keycode);
ksp = XGetKeyboardMapping(display, min_keycode,
@ -1572,6 +1667,19 @@ void X11DRV_InitKeyboard( BYTE *key_state_table )
}
/**********************************************************************
* GetAsyncKeyState (X11DRV.@)
*/
SHORT X11DRV_GetAsyncKeyState(INT key)
{
SHORT retval = ((key_state_table[key] & 0x40) ? 0x0001 : 0) |
((key_state_table[key] & 0x80) ? 0x8000 : 0);
key_state_table[key] &= ~0x40;
TRACE_(key)("(%x) -> %x\n", key, retval);
return retval;
}
/***********************************************************************
* GetKeyboardLayoutList (X11DRV.@)
*/
@ -1713,7 +1821,7 @@ void X11DRV_MappingNotify( HWND dummy, XEvent *event )
wine_tsx11_lock();
XRefreshKeyboardMapping(&event->xmapping);
wine_tsx11_unlock();
X11DRV_InitKeyboard( pKeyStateTable );
X11DRV_InitKeyboard();
hwnd = GetFocus();
if (!hwnd) hwnd = GetActiveWindow();

276
dlls/x11drv/mouse.c
View file

@ -34,6 +34,7 @@
#include "win.h"
#include "x11drv.h"
#include "wine/server.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(cursor);
@ -60,8 +61,7 @@ static const UINT button_up_flags[NB_BUTTONS] =
0
};
static BYTE *pKeyStateTable;
POINT cursor_pos;
/***********************************************************************
* get_coords
@ -86,9 +86,9 @@ static inline void get_coords( HWND hwnd, Window window, int x, int y, POINT *pt
*/
static void update_button_state( unsigned int state )
{
pKeyStateTable[VK_LBUTTON] = (state & Button1Mask ? 0x80 : 0);
pKeyStateTable[VK_MBUTTON] = (state & Button2Mask ? 0x80 : 0);
pKeyStateTable[VK_RBUTTON] = (state & Button3Mask ? 0x80 : 0);
key_state_table[VK_LBUTTON] = (state & Button1Mask ? 0x80 : 0);
key_state_table[VK_MBUTTON] = (state & Button2Mask ? 0x80 : 0);
key_state_table[VK_RBUTTON] = (state & Button3Mask ? 0x80 : 0);
}
@ -99,38 +99,190 @@ static void update_button_state( unsigned int state )
*/
static void update_key_state( unsigned int state )
{
pKeyStateTable[VK_SHIFT] = (state & ShiftMask ? 0x80 : 0);
pKeyStateTable[VK_CONTROL] = (state & ControlMask ? 0x80 : 0);
key_state_table[VK_SHIFT] = (state & ShiftMask ? 0x80 : 0);
key_state_table[VK_CONTROL] = (state & ControlMask ? 0x80 : 0);
}
/***********************************************************************
* send_mouse_event
* get_key_state
*/
static void send_mouse_event( HWND hwnd, DWORD flags, DWORD posX, DWORD posY,
DWORD data, Time time )
static WORD get_key_state(void)
{
INPUT input;
WORD ret = 0;
TRACE("(%04lX,%ld,%ld)\n", flags, posX, posY );
if (GetSystemMetrics( SM_SWAPBUTTON ))
{
if (key_state_table[VK_RBUTTON] & 0x80) ret |= MK_LBUTTON;
if (key_state_table[VK_LBUTTON] & 0x80) ret |= MK_RBUTTON;
}
else
{
if (key_state_table[VK_LBUTTON] & 0x80) ret |= MK_LBUTTON;
if (key_state_table[VK_RBUTTON] & 0x80) ret |= MK_RBUTTON;
}
if (key_state_table[VK_MBUTTON] & 0x80) ret |= MK_MBUTTON;
if (key_state_table[VK_SHIFT] & 0x80) ret |= MK_SHIFT;
if (key_state_table[VK_CONTROL] & 0x80) ret |= MK_CONTROL;
if (key_state_table[VK_XBUTTON1] & 0x80) ret |= MK_XBUTTON1;
if (key_state_table[VK_XBUTTON2] & 0x80) ret |= MK_XBUTTON2;
return ret;
}
/***********************************************************************
* queue_raw_mouse_message
*/
static void queue_raw_mouse_message( UINT message, HWND hwnd, DWORD x, DWORD y,
DWORD data, DWORD time, DWORD extra_info, UINT injected_flags )
{
MSLLHOOKSTRUCT hook;
hook.pt.x = x;
hook.pt.y = y;
hook.mouseData = MAKELONG( 0, data );
hook.flags = injected_flags;
hook.time = time;
hook.dwExtraInfo = extra_info;
if (HOOK_CallHooks( WH_MOUSE_LL, HC_ACTION, message, (LPARAM)&hook, TRUE )) return;
SERVER_START_REQ( send_message )
{
req->id = GetCurrentThreadId();
req->type = MSG_HARDWARE;
req->flags = 0;
req->win = hwnd;
req->msg = message;
req->wparam = MAKEWPARAM( get_key_state(), data );
req->lparam = 0;
req->x = x;
req->y = y;
req->time = time;
req->info = extra_info;
req->timeout = -1;
req->callback = NULL;
wine_server_call( req );
}
SERVER_END_REQ;
}
/***********************************************************************
* X11DRV_send_mouse_input
*/
void X11DRV_send_mouse_input( HWND hwnd, DWORD flags, DWORD x, DWORD y,
DWORD data, DWORD time, DWORD extra_info, UINT injected_flags )
{
POINT pt;
if (flags & MOUSEEVENTF_ABSOLUTE)
{
int width = GetSystemMetrics( SM_CXSCREEN );
int height = GetSystemMetrics( SM_CYSCREEN );
/* Relative mouse movements seem not to be scaled as absolute ones */
posX = (((long)posX << 16) + width-1) / width;
posY = (((long)posY << 16) + height-1) / height;
if (injected_flags & LLMHF_INJECTED)
{
pt.x = (x * screen_width) >> 16;
pt.y = (y * screen_height) >> 16;
}
else
{
pt.x = x;
pt.y = y;
}
wine_tsx11_lock();
cursor_pos = pt;
wine_tsx11_unlock();
}
else if (flags & MOUSEEVENTF_MOVE)
{
int accel[3], xMult = 1, yMult = 1;
/* dx and dy can be negative numbers for relative movements */
SystemParametersInfoW(SPI_GETMOUSE, 0, accel, 0);
if (x > accel[0] && accel[2] != 0)
{
xMult = 2;
if ((x > accel[1]) && (accel[2] == 2)) xMult = 4;
}
if (y > accel[0] && accel[2] != 0)
{
yMult = 2;
if ((y > accel[1]) && (accel[2] == 2)) yMult = 4;
}
wine_tsx11_lock();
pt.x = cursor_pos.x + (long)x * xMult;
pt.y = cursor_pos.y + (long)y * yMult;
/* Clip to the current screen size */
if (pt.x < 0) pt.x = 0;
else if (pt.x >= screen_width) pt.x = screen_width - 1;
if (pt.y < 0) pt.y = 0;
else if (pt.y >= screen_height) pt.y = screen_height - 1;
cursor_pos = pt;
wine_tsx11_unlock();
}
else
{
wine_tsx11_lock();
pt = cursor_pos;
wine_tsx11_unlock();
}
input.type = WINE_INTERNAL_INPUT_MOUSE;
input.u.mi.dx = posX;
input.u.mi.dy = posY;
input.u.mi.mouseData = data;
input.u.mi.dwFlags = flags;
input.u.mi.time = EVENT_x11_time_to_win32_time(time);
input.u.mi.dwExtraInfo = (ULONG_PTR)hwnd;
SendInput( 1, &input, sizeof(input) );
if (flags & MOUSEEVENTF_MOVE)
{
queue_raw_mouse_message( WM_MOUSEMOVE, hwnd, pt.x, pt.y, data, time,
extra_info, injected_flags );
if (injected_flags & LLMHF_INJECTED) /* we have to actually move the cursor */
{
TRACE( "warping to (%ld,%ld)\n", pt.x, pt.y );
wine_tsx11_lock();
XWarpPointer( thread_display(), root_window, root_window, 0, 0, 0, 0, pt.x, pt.y );
wine_tsx11_unlock();
}
}
if (flags & MOUSEEVENTF_LEFTDOWN)
{
key_state_table[VK_LBUTTON] |= 0xc0;
queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONDOWN : WM_LBUTTONDOWN,
hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
}
if (flags & MOUSEEVENTF_LEFTUP)
{
key_state_table[VK_LBUTTON] &= ~0x80;
queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONUP : WM_LBUTTONUP,
hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
}
if (flags & MOUSEEVENTF_RIGHTDOWN)
{
key_state_table[VK_RBUTTON] |= 0xc0;
queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONDOWN : WM_RBUTTONDOWN,
hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
}
if (flags & MOUSEEVENTF_RIGHTUP)
{
key_state_table[VK_RBUTTON] &= ~0x80;
queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONUP : WM_RBUTTONUP,
hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
}
if (flags & MOUSEEVENTF_MIDDLEDOWN)
{
key_state_table[VK_MBUTTON] |= 0xc0;
queue_raw_mouse_message( WM_MBUTTONDOWN, hwnd, pt.x, pt.y, data, time,
extra_info, injected_flags );
}
if (flags & MOUSEEVENTF_MIDDLEUP)
{
key_state_table[VK_MBUTTON] &= ~0x80;
queue_raw_mouse_message( WM_MBUTTONUP, hwnd, pt.x, pt.y, data, time,
extra_info, injected_flags );
}
if (flags & MOUSEEVENTF_WHEEL)
{
queue_raw_mouse_message( WM_MOUSEWHEEL, hwnd, pt.x, pt.y, data, time,
extra_info, injected_flags );
}
}
@ -489,7 +641,7 @@ void X11DRV_SetCursor( CURSORICONINFO *lpCursor )
/***********************************************************************
* SetCursorPos (X11DRV.@)
*/
void X11DRV_SetCursorPos( INT x, INT y )
BOOL X11DRV_SetCursorPos( INT x, INT y )
{
Display *display = thread_display();
@ -497,42 +649,37 @@ void X11DRV_SetCursorPos( INT x, INT y )
wine_tsx11_lock();
XWarpPointer( display, root_window, root_window, 0, 0, 0, 0, x, y );
XFlush( display ); /* just in case */
cursor_pos.x = x;
cursor_pos.y = y;
wine_tsx11_unlock();
return TRUE;
}
/***********************************************************************
* GetCursorPos (X11DRV.@)
*/
void X11DRV_GetCursorPos(LPPOINT pos)
BOOL X11DRV_GetCursorPos(LPPOINT pos)
{
Display *display = thread_display();
Window root, child;
int rootX, rootY, winX, winY;
unsigned int xstate;
Display *display = thread_display();
Window root, child;
int rootX, rootY, winX, winY;
unsigned int xstate;
wine_tsx11_lock();
if (XQueryPointer( display, root_window, &root, &child,
&rootX, &rootY, &winX, &winY, &xstate ))
{
update_key_state( xstate );
update_button_state( xstate );
TRACE("pointer at (%d,%d)\n", winX, winY );
pos->x = winX;
pos->y = winY;
}
wine_tsx11_unlock();
wine_tsx11_lock();
if (XQueryPointer( display, root_window, &root, &child,
&rootX, &rootY, &winX, &winY, &xstate ))
{
update_key_state( xstate );
update_button_state( xstate );
TRACE("pointer at (%d,%d)\n", winX, winY );
cursor_pos.x = winX;
cursor_pos.y = winY;
}
*pos = cursor_pos;
wine_tsx11_unlock();
return TRUE;
}
/***********************************************************************
* InitMouse (X11DRV.@)
*/
void X11DRV_InitMouse( BYTE *key_state_table )
{
pKeyStateTable = key_state_table;
}
/***********************************************************************
* X11DRV_ButtonPress
*/
@ -559,8 +706,8 @@ void X11DRV_ButtonPress( HWND hwnd, XEvent *xev )
break;
}
update_key_state( event->state );
send_mouse_event( hwnd, button_down_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE,
pt.x, pt.y, wData, event->time );
X11DRV_send_mouse_input( hwnd, button_down_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE,
pt.x, pt.y, wData, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
}
@ -579,8 +726,8 @@ void X11DRV_ButtonRelease( HWND hwnd, XEvent *xev )
update_cursor( hwnd, event->window );
get_coords( hwnd, event->window, event->x, event->y, &pt );
update_key_state( event->state );
send_mouse_event( hwnd, button_up_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE,
pt.x, pt.y, 0, event->time );
X11DRV_send_mouse_input( hwnd, button_up_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE,
pt.x, pt.y, 0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
}
@ -599,8 +746,8 @@ void X11DRV_MotionNotify( HWND hwnd, XEvent *xev )
update_cursor( hwnd, event->window );
get_coords( hwnd, event->window, event->x, event->y, &pt );
update_key_state( event->state );
send_mouse_event( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
pt.x, pt.y, 0, event->time );
X11DRV_send_mouse_input( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
pt.x, pt.y, 0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
}
@ -621,8 +768,8 @@ void X11DRV_EnterNotify( HWND hwnd, XEvent *xev )
update_cursor( hwnd, event->window );
get_coords( hwnd, event->window, event->x, event->y, &pt );
update_key_state( event->state );
send_mouse_event( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
pt.x, pt.y, 0, event->time );
X11DRV_send_mouse_input( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
pt.x, pt.y, 0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
}
@ -637,7 +784,8 @@ void X11DRV_DGAMotionEvent( HWND hwnd, XEvent *xev )
{
XDGAMotionEvent *event = (XDGAMotionEvent *)xev;
update_key_state( event->state );
send_mouse_event( DGAhwnd, MOUSEEVENTF_MOVE, event->dx, event->dy, 0, event->time );
X11DRV_send_mouse_input( DGAhwnd, MOUSEEVENTF_MOVE, event->dx, event->dy,
0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
}
/**********************************************************************
@ -650,7 +798,8 @@ void X11DRV_DGAButtonPressEvent( HWND hwnd, XEvent *xev )
if (buttonNum >= NB_BUTTONS) return;
update_key_state( event->state );
send_mouse_event( DGAhwnd, button_down_flags[buttonNum], 0, 0, 0, event->time );
X11DRV_send_mouse_input( DGAhwnd, button_down_flags[buttonNum], 0, 0,
0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
}
/**********************************************************************
@ -663,7 +812,8 @@ void X11DRV_DGAButtonReleaseEvent( HWND hwnd, XEvent *xev )
if (buttonNum >= NB_BUTTONS) return;
update_key_state( event->state );
send_mouse_event( DGAhwnd, button_up_flags[buttonNum], 0, 0, 0, event->time );
X11DRV_send_mouse_input( DGAhwnd, button_up_flags[buttonNum], 0, 0,
0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
}
#endif /* HAVE_LIBXXF86DGA2 */

535
dlls/x11drv/x11drv.h
View file

@ -287,271 +287,6 @@ typedef struct
/* DIB Section sync state */
enum { DIB_Status_None, DIB_Status_InSync, DIB_Status_GdiMod, DIB_Status_AppMod, DIB_Status_AuxMod };
extern int *X11DRV_DIB_BuildColorMap( X11DRV_PDEVICE *physDev, WORD coloruse,
WORD depth, const BITMAPINFO *info,
int *nColors );
extern INT X11DRV_CoerceDIBSection(X11DRV_PDEVICE *physDev,INT,BOOL);
extern INT X11DRV_LockDIBSection(X11DRV_PDEVICE *physDev,INT,BOOL);
extern void X11DRV_UnlockDIBSection(X11DRV_PDEVICE *physDev,BOOL);
extern INT X11DRV_CoerceDIBSection2(HBITMAP bmp,INT,BOOL);
extern INT X11DRV_LockDIBSection2(HBITMAP bmp,INT,BOOL);
extern void X11DRV_UnlockDIBSection2(HBITMAP bmp,BOOL);
extern HBITMAP X11DRV_DIB_CreateDIBSection(X11DRV_PDEVICE *physDev, const BITMAPINFO *bmi, UINT usage,
VOID **bits, HANDLE section, DWORD offset, DWORD ovr_pitch);
extern void X11DRV_DIB_DeleteDIBSection(struct tagBITMAPOBJ *bmp);
extern INT X11DRV_DIB_Coerce(struct tagBITMAPOBJ *,INT,BOOL);
extern INT X11DRV_DIB_Lock(struct tagBITMAPOBJ *,INT,BOOL);
extern void X11DRV_DIB_Unlock(struct tagBITMAPOBJ *,BOOL);
void X11DRV_DIB_CopyDIBSection(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
DWORD xSrc, DWORD ySrc, DWORD xDest, DWORD yDest,
DWORD width, DWORD height);
struct _DCICMD;
extern INT X11DRV_DCICommand(INT cbInput, const struct _DCICMD *lpCmd, LPVOID lpOutData);
/**************************************************************************
* X11 GDI driver
*/
extern void X11DRV_GDI_Initialize( Display *display );
extern void X11DRV_GDI_Finalize(void);
extern Display *gdi_display; /* display to use for all GDI functions */
/* X11 GDI palette driver */
#define X11DRV_PALETTE_FIXED 0x0001 /* read-only colormap - have to use XAllocColor (if not virtual) */
#define X11DRV_PALETTE_VIRTUAL 0x0002 /* no mapping needed - pixel == pixel color */
#define X11DRV_PALETTE_PRIVATE 0x1000 /* private colormap, identity mapping */
#define X11DRV_PALETTE_WHITESET 0x2000
extern Colormap X11DRV_PALETTE_PaletteXColormap;
extern UINT16 X11DRV_PALETTE_PaletteFlags;
extern int *X11DRV_PALETTE_PaletteToXPixel;
extern int *X11DRV_PALETTE_XPixelToPalette;
extern int X11DRV_PALETTE_mapEGAPixel[16];
extern int X11DRV_PALETTE_Init(void);
extern void X11DRV_PALETTE_Cleanup(void);
extern BOOL X11DRV_IsSolidColor(COLORREF color);
extern COLORREF X11DRV_PALETTE_ToLogical(int pixel);
extern int X11DRV_PALETTE_ToPhysical(X11DRV_PDEVICE *physDev, COLORREF color);
/* GDI escapes */
#define X11DRV_ESCAPE 6789
enum x11drv_escape_codes
{
X11DRV_GET_DISPLAY, /* get X11 display for a DC */
X11DRV_GET_DRAWABLE, /* get current drawable for a DC */
X11DRV_GET_FONT, /* get current X font for a DC */
X11DRV_SET_DRAWABLE, /* set current drawable for a DC */
X11DRV_START_EXPOSURES, /* start graphics exposures */
X11DRV_END_EXPOSURES, /* end graphics exposures */
};
struct x11drv_escape_set_drawable
{
enum x11drv_escape_codes code; /* escape code (X11DRV_SET_DRAWABLE) */
Drawable drawable; /* X drawable */
int mode; /* ClipByChildren or IncludeInferiors */
POINT org; /* origin of DC relative to drawable */
POINT drawable_org; /* origin of drawable relative to screen */
};
/**************************************************************************
* X11 USER driver
*/
struct x11drv_thread_data
{
Display *display;
HANDLE display_fd;
int process_event_count; /* recursion count for event processing */
Cursor cursor; /* current cursor */
Window cursor_window; /* current window that contains the cursor */
HWND last_focus; /* last window that had focus */
XIM xim; /* input method */
Window selection_wnd; /* window used for selection interactions */
};
extern struct x11drv_thread_data *x11drv_init_thread_data(void);
inline static struct x11drv_thread_data *x11drv_thread_data(void)
{
struct x11drv_thread_data *data = NtCurrentTeb()->driver_data;
if (!data) data = x11drv_init_thread_data();
return data;
}
inline static Display *thread_display(void) { return x11drv_thread_data()->display; }
extern Visual *visual;
extern Window root_window;
extern DWORD desktop_tid;
extern unsigned int screen_width;
extern unsigned int screen_height;
extern unsigned int screen_depth;
extern unsigned int text_caps;
extern int use_xkb;
extern int use_take_focus;
extern int managed_mode;
/* atoms */
enum x11drv_atoms
{
FIRST_XATOM = XA_LAST_PREDEFINED + 1,
XATOM_CLIPBOARD = FIRST_XATOM,
XATOM_COMPOUND_TEXT,
XATOM_MULTIPLE,
XATOM_SELECTION_DATA,
XATOM_TARGETS,
XATOM_TEXT,
XATOM_UTF8_STRING,
XATOM_RAW_ASCENT,
XATOM_RAW_DESCENT,
XATOM_RAW_CAP_HEIGHT,
XATOM_WM_PROTOCOLS,
XATOM_WM_DELETE_WINDOW,
XATOM_WM_TAKE_FOCUS,
XATOM_KWM_DOCKWINDOW,
XATOM_DndProtocol,
XATOM_DndSelection,
XATOM__MOTIF_WM_HINTS,
XATOM__KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR,
XATOM__NET_WM_MOVERESIZE,
XATOM__NET_WM_PID,
XATOM__NET_WM_PING,
XATOM__NET_WM_NAME,
XATOM__NET_WM_WINDOW_TYPE,
XATOM__NET_WM_WINDOW_TYPE_UTILITY,
XATOM_XdndAware,
XATOM_XdndEnter,
XATOM_XdndPosition,
XATOM_XdndStatus,
XATOM_XdndLeave,
XATOM_XdndFinished,
XATOM_XdndDrop,
XATOM_XdndActionCopy,
XATOM_XdndActionMove,
XATOM_XdndActionLink,
XATOM_XdndActionAsk,
XATOM_XdndActionPrivate,
XATOM_XdndSelection,
XATOM_XdndTarget,
XATOM_XdndTypeList,
XATOM_WCF_DIB,
XATOM_image_gif,
XATOM_text_html,
XATOM_text_plain,
XATOM_text_rtf,
XATOM_text_richtext,
NB_XATOMS
};
extern Atom X11DRV_Atoms[NB_XATOMS - FIRST_XATOM];
#define x11drv_atom(name) (X11DRV_Atoms[XATOM_##name - FIRST_XATOM])
/* X11 event driver */
typedef void (*x11drv_event_handler)( HWND hwnd, XEvent *event );
extern void X11DRV_register_event_handler( int type, x11drv_event_handler handler );
extern void X11DRV_ButtonPress( HWND hwnd, XEvent *event );
extern void X11DRV_ButtonRelease( HWND hwnd, XEvent *event );
extern void X11DRV_MotionNotify( HWND hwnd, XEvent *event );
extern void X11DRV_EnterNotify( HWND hwnd, XEvent *event );
extern void X11DRV_KeyEvent( HWND hwnd, XEvent *event );
extern void X11DRV_KeymapNotify( HWND hwnd, XEvent *event );
extern void X11DRV_Expose( HWND hwnd, XEvent *event );
extern void X11DRV_MapNotify( HWND hwnd, XEvent *event );
extern void X11DRV_UnmapNotify( HWND hwnd, XEvent *event );
extern void X11DRV_ConfigureNotify( HWND hwnd, XEvent *event );
extern void X11DRV_SelectionRequest( HWND hWnd, XEvent *event );
extern void X11DRV_SelectionClear( HWND hWnd, XEvent *event );
extern void X11DRV_MappingNotify( HWND hWnd, XEvent *event );
extern void X11DRV_DGAMotionEvent( HWND hwnd, XEvent *event );
extern void X11DRV_DGAButtonPressEvent( HWND hwnd, XEvent *event );
extern void X11DRV_DGAButtonReleaseEvent( HWND hwnd, XEvent *event );
extern DWORD EVENT_x11_time_to_win32_time(Time time);
/* X11 driver private messages, must be in the range 0x80001000..0x80001fff */
enum x11drv_window_messages
{
WM_X11DRV_ACQUIRE_SELECTION = 0x80001000
};
/* x11drv private window data */
struct x11drv_win_data
{
HWND hwnd; /* hwnd that this private data belongs to */
Window whole_window; /* X window for the complete window */
Window icon_window; /* X window for the icon */
RECT window_rect; /* USER window rectangle relative to parent */
RECT whole_rect; /* X window rectangle for the whole window relative to parent */
RECT client_rect; /* client area relative to whole window */
XIC xic; /* X input context */
BOOL managed; /* is window managed? */
HBITMAP hWMIconBitmap;
HBITMAP hWMIconMask;
};
extern struct x11drv_win_data *X11DRV_get_win_data( HWND hwnd );
extern POINT X11DRV_get_client_area_offset( HWND hwnd );
extern Window X11DRV_get_whole_window( HWND hwnd );
extern BOOL X11DRV_is_window_rect_mapped( const RECT *rect );
extern XIC X11DRV_get_ic( HWND hwnd );
/* X context to associate a hwnd to an X window */
extern XContext winContext;
extern void X11DRV_InitClipboard(void);
extern void X11DRV_AcquireClipboard(HWND hWndClipWindow);
extern void X11DRV_SetFocus( HWND hwnd );
extern Cursor X11DRV_GetCursor( Display *display, struct tagCURSORICONINFO *ptr );
typedef int (*x11drv_error_callback)( Display *display, XErrorEvent *event, void *arg );
extern void X11DRV_expect_error( Display *display, x11drv_error_callback callback, void *arg );
extern int X11DRV_check_error(void);
extern void X11DRV_set_iconic_state( HWND hwnd );
extern void X11DRV_window_to_X_rect( struct x11drv_win_data *data, RECT *rect );
extern void X11DRV_X_to_window_rect( struct x11drv_win_data *data, RECT *rect );
extern void X11DRV_create_desktop_thread(void);
extern Window X11DRV_create_desktop( XVisualInfo *desktop_vi, const char *geometry );
extern void X11DRV_sync_window_style( Display *display, struct x11drv_win_data *data );
extern void X11DRV_sync_window_position( Display *display, struct x11drv_win_data *data,
UINT swp_flags, const RECT *new_client_rect,
const RECT *new_whole_rect );
extern BOOL X11DRV_set_window_pos( HWND hwnd, HWND insert_after, const RECT *rectWindow,
const RECT *rectClient, UINT swp_flags, const RECT *validRects );
extern void X11DRV_set_wm_hints( Display *display, struct x11drv_win_data *data );
extern void X11DRV_handle_desktop_resize(unsigned int width, unsigned int height);
extern void X11DRV_Settings_AddDepthModes(void);
extern void X11DRV_Settings_AddOneMode(unsigned int width, unsigned int height, unsigned int bpp, unsigned int freq);
extern int X11DRV_Settings_CreateDriver(LPDDHALINFO info);
extern LPDDHALMODEINFO X11DRV_Settings_CreateModes(unsigned int max_modes, int reserve_depths);
unsigned int X11DRV_Settings_GetModeCount(void);
void X11DRV_Settings_Init(void);
extern void X11DRV_Settings_SetDefaultMode(int mode);
LPDDHALMODEINFO X11DRV_Settings_SetHandlers(const char *name,
int (*pNewGCM)(void),
void (*pNewSCM)(int),
unsigned int nmodes,
int reserve_depths);
typedef struct {
void (*Convert_5x5_asis)(int width, int height,
const void* srcbits, int srclinebytes,
@ -682,5 +417,275 @@ typedef struct {
extern const dib_conversions dib_normal, dib_src_byteswap, dib_dst_byteswap;
extern INT X11DRV_DIB_MaskToShift(DWORD mask);
extern int *X11DRV_DIB_BuildColorMap( X11DRV_PDEVICE *physDev, WORD coloruse,
WORD depth, const BITMAPINFO *info,
int *nColors );
extern INT X11DRV_CoerceDIBSection(X11DRV_PDEVICE *physDev,INT,BOOL);
extern INT X11DRV_LockDIBSection(X11DRV_PDEVICE *physDev,INT,BOOL);
extern void X11DRV_UnlockDIBSection(X11DRV_PDEVICE *physDev,BOOL);
extern INT X11DRV_CoerceDIBSection2(HBITMAP bmp,INT,BOOL);
extern INT X11DRV_LockDIBSection2(HBITMAP bmp,INT,BOOL);
extern void X11DRV_UnlockDIBSection2(HBITMAP bmp,BOOL);
extern HBITMAP X11DRV_DIB_CreateDIBSection(X11DRV_PDEVICE *physDev, const BITMAPINFO *bmi, UINT usage,
VOID **bits, HANDLE section, DWORD offset, DWORD ovr_pitch);
extern void X11DRV_DIB_DeleteDIBSection(struct tagBITMAPOBJ *bmp);
extern INT X11DRV_DIB_Coerce(struct tagBITMAPOBJ *,INT,BOOL);
extern INT X11DRV_DIB_Lock(struct tagBITMAPOBJ *,INT,BOOL);
extern void X11DRV_DIB_Unlock(struct tagBITMAPOBJ *,BOOL);
void X11DRV_DIB_CopyDIBSection(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
DWORD xSrc, DWORD ySrc, DWORD xDest, DWORD yDest,
DWORD width, DWORD height);
struct _DCICMD;
extern INT X11DRV_DCICommand(INT cbInput, const struct _DCICMD *lpCmd, LPVOID lpOutData);
/**************************************************************************
* X11 GDI driver
*/
extern void X11DRV_GDI_Initialize( Display *display );
extern void X11DRV_GDI_Finalize(void);
extern Display *gdi_display; /* display to use for all GDI functions */
/* X11 GDI palette driver */
#define X11DRV_PALETTE_FIXED 0x0001 /* read-only colormap - have to use XAllocColor (if not virtual) */
#define X11DRV_PALETTE_VIRTUAL 0x0002 /* no mapping needed - pixel == pixel color */
#define X11DRV_PALETTE_PRIVATE 0x1000 /* private colormap, identity mapping */
#define X11DRV_PALETTE_WHITESET 0x2000
extern Colormap X11DRV_PALETTE_PaletteXColormap;
extern UINT16 X11DRV_PALETTE_PaletteFlags;
extern int *X11DRV_PALETTE_PaletteToXPixel;
extern int *X11DRV_PALETTE_XPixelToPalette;
extern int X11DRV_PALETTE_mapEGAPixel[16];
extern int X11DRV_PALETTE_Init(void);
extern void X11DRV_PALETTE_Cleanup(void);
extern BOOL X11DRV_IsSolidColor(COLORREF color);
extern COLORREF X11DRV_PALETTE_ToLogical(int pixel);
extern int X11DRV_PALETTE_ToPhysical(X11DRV_PDEVICE *physDev, COLORREF color);
/* GDI escapes */
#define X11DRV_ESCAPE 6789
enum x11drv_escape_codes
{
X11DRV_GET_DISPLAY, /* get X11 display for a DC */
X11DRV_GET_DRAWABLE, /* get current drawable for a DC */
X11DRV_GET_FONT, /* get current X font for a DC */
X11DRV_SET_DRAWABLE, /* set current drawable for a DC */
X11DRV_START_EXPOSURES, /* start graphics exposures */
X11DRV_END_EXPOSURES, /* end graphics exposures */
};
struct x11drv_escape_set_drawable
{
enum x11drv_escape_codes code; /* escape code (X11DRV_SET_DRAWABLE) */
Drawable drawable; /* X drawable */
int mode; /* ClipByChildren or IncludeInferiors */
POINT org; /* origin of DC relative to drawable */
POINT drawable_org; /* origin of drawable relative to screen */
};
/**************************************************************************
* X11 USER driver
*/
struct x11drv_thread_data
{
Display *display;
HANDLE display_fd;
int process_event_count; /* recursion count for event processing */
Cursor cursor; /* current cursor */
Window cursor_window; /* current window that contains the cursor */
HWND last_focus; /* last window that had focus */
XIM xim; /* input method */
Window selection_wnd; /* window used for selection interactions */
};
extern struct x11drv_thread_data *x11drv_init_thread_data(void);
inline static struct x11drv_thread_data *x11drv_thread_data(void)
{
struct x11drv_thread_data *data = NtCurrentTeb()->driver_data;
if (!data) data = x11drv_init_thread_data();
return data;
}
inline static Display *thread_display(void) { return x11drv_thread_data()->display; }
extern Visual *visual;
extern Window root_window;
extern DWORD desktop_tid;
extern unsigned int screen_width;
extern unsigned int screen_height;
extern unsigned int screen_depth;
extern unsigned int text_caps;
extern int use_xkb;
extern int use_take_focus;
extern int managed_mode;
extern BYTE key_state_table[256];
extern POINT cursor_pos;
/* atoms */
enum x11drv_atoms
{
FIRST_XATOM = XA_LAST_PREDEFINED + 1,
XATOM_CLIPBOARD = FIRST_XATOM,
XATOM_COMPOUND_TEXT,
XATOM_MULTIPLE,
XATOM_SELECTION_DATA,
XATOM_TARGETS,
XATOM_TEXT,
XATOM_UTF8_STRING,
XATOM_RAW_ASCENT,
XATOM_RAW_DESCENT,
XATOM_RAW_CAP_HEIGHT,
XATOM_WM_PROTOCOLS,
XATOM_WM_DELETE_WINDOW,
XATOM_WM_TAKE_FOCUS,
XATOM_KWM_DOCKWINDOW,
XATOM_DndProtocol,
XATOM_DndSelection,
XATOM__MOTIF_WM_HINTS,
XATOM__KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR,
XATOM__NET_WM_MOVERESIZE,
XATOM__NET_WM_PID,
XATOM__NET_WM_PING,
XATOM__NET_WM_NAME,
XATOM__NET_WM_WINDOW_TYPE,
XATOM__NET_WM_WINDOW_TYPE_UTILITY,
XATOM_XdndAware,
XATOM_XdndEnter,
XATOM_XdndPosition,
XATOM_XdndStatus,
XATOM_XdndLeave,
XATOM_XdndFinished,
XATOM_XdndDrop,
XATOM_XdndActionCopy,
XATOM_XdndActionMove,
XATOM_XdndActionLink,
XATOM_XdndActionAsk,
XATOM_XdndActionPrivate,
XATOM_XdndSelection,
XATOM_XdndTarget,
XATOM_XdndTypeList,
XATOM_WCF_DIB,
XATOM_image_gif,
XATOM_text_html,
XATOM_text_plain,
XATOM_text_rtf,
XATOM_text_richtext,
NB_XATOMS
};
extern Atom X11DRV_Atoms[NB_XATOMS - FIRST_XATOM];
#define x11drv_atom(name) (X11DRV_Atoms[XATOM_##name - FIRST_XATOM])
/* X11 event driver */
typedef void (*x11drv_event_handler)( HWND hwnd, XEvent *event );
extern void X11DRV_register_event_handler( int type, x11drv_event_handler handler );
extern void X11DRV_ButtonPress( HWND hwnd, XEvent *event );
extern void X11DRV_ButtonRelease( HWND hwnd, XEvent *event );
extern void X11DRV_MotionNotify( HWND hwnd, XEvent *event );
extern void X11DRV_EnterNotify( HWND hwnd, XEvent *event );
extern void X11DRV_KeyEvent( HWND hwnd, XEvent *event );
extern void X11DRV_KeymapNotify( HWND hwnd, XEvent *event );
extern void X11DRV_Expose( HWND hwnd, XEvent *event );
extern void X11DRV_MapNotify( HWND hwnd, XEvent *event );
extern void X11DRV_UnmapNotify( HWND hwnd, XEvent *event );
extern void X11DRV_ConfigureNotify( HWND hwnd, XEvent *event );
extern void X11DRV_SelectionRequest( HWND hWnd, XEvent *event );
extern void X11DRV_SelectionClear( HWND hWnd, XEvent *event );
extern void X11DRV_MappingNotify( HWND hWnd, XEvent *event );
extern void X11DRV_DGAMotionEvent( HWND hwnd, XEvent *event );
extern void X11DRV_DGAButtonPressEvent( HWND hwnd, XEvent *event );
extern void X11DRV_DGAButtonReleaseEvent( HWND hwnd, XEvent *event );
extern DWORD EVENT_x11_time_to_win32_time(Time time);
/* X11 driver private messages, must be in the range 0x80001000..0x80001fff */
enum x11drv_window_messages
{
WM_X11DRV_ACQUIRE_SELECTION = 0x80001000
};
/* x11drv private window data */
struct x11drv_win_data
{
HWND hwnd; /* hwnd that this private data belongs to */
Window whole_window; /* X window for the complete window */
Window icon_window; /* X window for the icon */
RECT window_rect; /* USER window rectangle relative to parent */
RECT whole_rect; /* X window rectangle for the whole window relative to parent */
RECT client_rect; /* client area relative to whole window */
XIC xic; /* X input context */
BOOL managed; /* is window managed? */
HBITMAP hWMIconBitmap;
HBITMAP hWMIconMask;
};
extern struct x11drv_win_data *X11DRV_get_win_data( HWND hwnd );
extern POINT X11DRV_get_client_area_offset( HWND hwnd );
extern Window X11DRV_get_whole_window( HWND hwnd );
extern BOOL X11DRV_is_window_rect_mapped( const RECT *rect );
extern XIC X11DRV_get_ic( HWND hwnd );
/* X context to associate a hwnd to an X window */
extern XContext winContext;
extern void X11DRV_InitClipboard(void);
extern void X11DRV_AcquireClipboard(HWND hWndClipWindow);
extern void X11DRV_SetFocus( HWND hwnd );
extern Cursor X11DRV_GetCursor( Display *display, struct tagCURSORICONINFO *ptr );
extern void X11DRV_InitKeyboard(void);
extern void X11DRV_send_keyboard_input( WORD wVk, WORD wScan, DWORD dwFlags, DWORD time,
DWORD dwExtraInfo, UINT injected_flags );
extern void X11DRV_send_mouse_input( HWND hwnd, DWORD flags, DWORD x, DWORD y,
DWORD data, DWORD time, DWORD extra_info, UINT injected_flags );
typedef int (*x11drv_error_callback)( Display *display, XErrorEvent *event, void *arg );
extern void X11DRV_expect_error( Display *display, x11drv_error_callback callback, void *arg );
extern int X11DRV_check_error(void);
extern void X11DRV_set_iconic_state( HWND hwnd );
extern void X11DRV_window_to_X_rect( struct x11drv_win_data *data, RECT *rect );
extern void X11DRV_X_to_window_rect( struct x11drv_win_data *data, RECT *rect );
extern void X11DRV_create_desktop_thread(void);
extern Window X11DRV_create_desktop( XVisualInfo *desktop_vi, const char *geometry );
extern void X11DRV_sync_window_style( Display *display, struct x11drv_win_data *data );
extern void X11DRV_sync_window_position( Display *display, struct x11drv_win_data *data,
UINT swp_flags, const RECT *new_client_rect,
const RECT *new_whole_rect );
extern BOOL X11DRV_set_window_pos( HWND hwnd, HWND insert_after, const RECT *rectWindow,
const RECT *rectClient, UINT swp_flags, const RECT *validRects );
extern void X11DRV_set_wm_hints( Display *display, struct x11drv_win_data *data );
extern void X11DRV_handle_desktop_resize(unsigned int width, unsigned int height);
extern void X11DRV_Settings_AddDepthModes(void);
extern void X11DRV_Settings_AddOneMode(unsigned int width, unsigned int height, unsigned int bpp, unsigned int freq);
extern int X11DRV_Settings_CreateDriver(LPDDHALINFO info);
extern LPDDHALMODEINFO X11DRV_Settings_CreateModes(unsigned int max_modes, int reserve_depths);
unsigned int X11DRV_Settings_GetModeCount(void);
void X11DRV_Settings_Init(void);
extern void X11DRV_Settings_SetDefaultMode(int mode);
LPDDHALMODEINFO X11DRV_Settings_SetHandlers(const char *name,
int (*pNewGCM)(void),
void (*pNewSCM)(int),
unsigned int nmodes,
int reserve_depths);
#endif /* __WINE_X11DRV_H */

16
dlls/x11drv/x11drv.spec
View file

@ -63,19 +63,19 @@
# USER driver
@ cdecl InitKeyboard(ptr) X11DRV_InitKeyboard
@ cdecl VkKeyScanEx(long long) X11DRV_VkKeyScanEx
@ cdecl MapVirtualKeyEx(long long long) X11DRV_MapVirtualKeyEx
@ cdecl ActivateKeyboardLayout(long long) X11DRV_ActivateKeyboardLayout
@ cdecl Beep() X11DRV_Beep
@ cdecl GetAsyncKeyState(long) X11DRV_GetAsyncKeyState
@ cdecl GetKeyNameText(long ptr long) X11DRV_GetKeyNameText
@ cdecl ToUnicodeEx(long long ptr ptr long long long) X11DRV_ToUnicodeEx
@ cdecl GetKeyboardLayoutList(long ptr) X11DRV_GetKeyboardLayoutList
@ cdecl GetKeyboardLayout(long) X11DRV_GetKeyboardLayout
@ cdecl GetKeyboardLayoutList(long ptr) X11DRV_GetKeyboardLayoutList
@ cdecl GetKeyboardLayoutName(ptr) X11DRV_GetKeyboardLayoutName
@ cdecl LoadKeyboardLayout(wstr long) X11DRV_LoadKeyboardLayout
@ cdecl ActivateKeyboardLayout(long long) X11DRV_ActivateKeyboardLayout
@ cdecl MapVirtualKeyEx(long long long) X11DRV_MapVirtualKeyEx
@ cdecl SendInput(long ptr long) X11DRV_SendInput
@ cdecl ToUnicodeEx(long long ptr ptr long long long) X11DRV_ToUnicodeEx
@ cdecl UnloadKeyboardLayout(long) X11DRV_UnloadKeyboardLayout
@ cdecl Beep() X11DRV_Beep
@ cdecl InitMouse(ptr) X11DRV_InitMouse
@ cdecl VkKeyScanEx(long long) X11DRV_VkKeyScanEx
@ cdecl SetCursor(ptr) X11DRV_SetCursor
@ cdecl GetCursorPos(ptr) X11DRV_GetCursorPos
@ cdecl SetCursorPos(long long) X11DRV_SetCursorPos

2
dlls/x11drv/x11drv_main.c
View file

@ -394,6 +394,8 @@ static BOOL process_attach(void)
X11DRV_XF86DGA2_Init();
#endif
X11DRV_InitKeyboard();
return TRUE;
}

4
include/win.h
View file

@ -95,10 +95,6 @@ extern BOOL WIN_IsWindowDrawable( HWND hwnd, BOOL );
extern HWND *WIN_ListChildren( HWND hwnd );
extern void MDI_CalcDefaultChildPos( HWND hwndClient, INT total, LPPOINT lpPos, INT delta, UINT *id );
/* internal SendInput codes (FIXME) */
#define WINE_INTERNAL_INPUT_MOUSE (16+INPUT_MOUSE)
#define WINE_INTERNAL_INPUT_KEYBOARD (16+INPUT_KEYBOARD)
/* user lock */
extern void USER_Lock(void);
extern void USER_Unlock(void);

326
windows/input.c
View file

@ -40,46 +40,14 @@
#include "winuser.h"
#include "winnls.h"
#include "wine/server.h"
#include "win.h"
#include "message.h"
#include "user_private.h"
#include "winternl.h"
#include "wine/debug.h"
#include "winerror.h"
WINE_DECLARE_DEBUG_CHANNEL(key);
WINE_DEFAULT_DEBUG_CHANNEL(key);
WINE_DECLARE_DEBUG_CHANNEL(keyboard);
WINE_DECLARE_DEBUG_CHANNEL(win);
WINE_DEFAULT_DEBUG_CHANNEL(event);
BYTE InputKeyStateTable[256];
static BYTE AsyncKeyStateTable[256];
static BYTE TrackSysKey = 0; /* determine whether ALT key up will cause a WM_SYSKEYUP
or a WM_KEYUP message */
/* Storage for the USER-maintained mouse positions */
static DWORD PosX, PosY;
typedef union
{
struct
{
#ifndef BITFIELDS_BIGENDIAN
unsigned long count : 16;
#endif
unsigned long code : 8;
unsigned long extended : 1;
unsigned long unused : 2;
unsigned long win_internal : 2;
unsigned long context : 1;
unsigned long previous : 1;
unsigned long transition : 1;
#ifdef BITFIELDS_BIGENDIAN
unsigned long count : 16;
#endif
} lp1;
unsigned long lp2;
} KEYLP;
/***********************************************************************
@ -91,274 +59,30 @@ static WORD get_key_state(void)
if (GetSystemMetrics( SM_SWAPBUTTON ))
{
if (InputKeyStateTable[VK_RBUTTON] & 0x80) ret |= MK_LBUTTON;
if (InputKeyStateTable[VK_LBUTTON] & 0x80) ret |= MK_RBUTTON;
if (GetAsyncKeyState(VK_RBUTTON) & 0x80) ret |= MK_LBUTTON;
if (GetAsyncKeyState(VK_LBUTTON) & 0x80) ret |= MK_RBUTTON;
}
else
{
if (InputKeyStateTable[VK_LBUTTON] & 0x80) ret |= MK_LBUTTON;
if (InputKeyStateTable[VK_RBUTTON] & 0x80) ret |= MK_RBUTTON;
if (GetAsyncKeyState(VK_LBUTTON) & 0x80) ret |= MK_LBUTTON;
if (GetAsyncKeyState(VK_RBUTTON) & 0x80) ret |= MK_RBUTTON;
}
if (InputKeyStateTable[VK_MBUTTON] & 0x80) ret |= MK_MBUTTON;
if (InputKeyStateTable[VK_SHIFT] & 0x80) ret |= MK_SHIFT;
if (InputKeyStateTable[VK_CONTROL] & 0x80) ret |= MK_CONTROL;
if (InputKeyStateTable[VK_XBUTTON1] & 0x80) ret |= MK_XBUTTON1;
if (InputKeyStateTable[VK_XBUTTON2] & 0x80) ret |= MK_XBUTTON2;
if (GetAsyncKeyState(VK_MBUTTON) & 0x80) ret |= MK_MBUTTON;
if (GetAsyncKeyState(VK_SHIFT) & 0x80) ret |= MK_SHIFT;
if (GetAsyncKeyState(VK_CONTROL) & 0x80) ret |= MK_CONTROL;
if (GetAsyncKeyState(VK_XBUTTON1) & 0x80) ret |= MK_XBUTTON1;
if (GetAsyncKeyState(VK_XBUTTON2) & 0x80) ret |= MK_XBUTTON2;
return ret;
}
/***********************************************************************
* queue_hardware_message
*
* Add a message to the hardware queue.
* Note: the position is relative to the desktop window.
*/
static void queue_hardware_message( UINT message, HWND hwnd, WPARAM wParam, LPARAM lParam,
int xPos, int yPos, DWORD time, ULONG_PTR extraInfo )
{
SERVER_START_REQ( send_message )
{
req->id = GetCurrentThreadId();
req->type = MSG_HARDWARE;
req->flags = 0;
req->win = hwnd;
req->msg = message;
req->wparam = wParam;
req->lparam = lParam;
req->x = xPos;
req->y = yPos;
req->time = time;
req->info = extraInfo;
req->timeout = -1;
req->callback = NULL;
wine_server_call( req );
}
SERVER_END_REQ;
}
/***********************************************************************
* queue_kbd_event
*
* Put a keyboard event into a thread queue
*/
static void queue_kbd_event( const KEYBDINPUT *ki, UINT injected_flags )
{
UINT message;
KEYLP keylp;
KBDLLHOOKSTRUCT hook;
keylp.lp2 = 0;
keylp.lp1.count = 1;
keylp.lp1.code = ki->wScan;
keylp.lp1.extended = (ki->dwFlags & KEYEVENTF_EXTENDEDKEY) != 0;
keylp.lp1.win_internal = 0; /* this has something to do with dialogs,
* don't remember where I read it - AK */
/* it's '1' under windows, when a dialog box appears
* and you press one of the underlined keys - DF*/
/* note that there is a test for all this */
if (ki->dwFlags & KEYEVENTF_KEYUP )
{
message = WM_KEYUP;
if( (InputKeyStateTable[VK_MENU] & 0x80) && (
(ki->wVk == VK_MENU) || (ki->wVk == VK_CONTROL) ||
!(InputKeyStateTable[VK_CONTROL] & 0x80))) {
if( TrackSysKey == VK_MENU || /* <ALT>-down/<ALT>-up sequence */
(ki->wVk != VK_MENU)) /* <ALT>-down...<something else>-up */
message = WM_SYSKEYUP;
TrackSysKey = 0;
}
InputKeyStateTable[ki->wVk] &= ~0x80;
keylp.lp1.previous = 1;
keylp.lp1.transition = 1;
}
else
{
keylp.lp1.previous = (InputKeyStateTable[ki->wVk] & 0x80) != 0;
keylp.lp1.transition = 0;
if (!(InputKeyStateTable[ki->wVk] & 0x80)) InputKeyStateTable[ki->wVk] ^= 0x01;
InputKeyStateTable[ki->wVk] |= 0x80;
AsyncKeyStateTable[ki->wVk] |= 0x80;
message = WM_KEYDOWN;
if( (InputKeyStateTable[VK_MENU] & 0x80) &&
!(InputKeyStateTable[VK_CONTROL] & 0x80)) {
message = WM_SYSKEYDOWN;
TrackSysKey = ki->wVk;
}
}
keylp.lp1.context = (InputKeyStateTable[VK_MENU] & 0x80) != 0; /* 1 if alt */
TRACE_(key)(" wParam=%04x, lParam=%08lx, InputKeyState=%x\n",
ki->wVk, keylp.lp2, InputKeyStateTable[ki->wVk] );
hook.vkCode = ki->wVk;
hook.scanCode = ki->wScan;
hook.flags = (keylp.lp2 >> 24) | injected_flags;
hook.time = ki->time;
hook.dwExtraInfo = ki->dwExtraInfo;
if (!HOOK_CallHooks( WH_KEYBOARD_LL, HC_ACTION, message, (LPARAM)&hook, TRUE ))
queue_hardware_message( message, 0, ki->wVk, keylp.lp2,
PosX, PosY, ki->time, ki->dwExtraInfo );
}
/***********************************************************************
* queue_raw_mouse_message
*/
static void queue_raw_mouse_message( UINT message, UINT flags, INT x, INT y, const MOUSEINPUT *mi )
{
MSLLHOOKSTRUCT hook;
hook.pt.x = x;
hook.pt.y = y;
hook.mouseData = MAKELONG( 0, mi->mouseData );
hook.flags = flags;
hook.time = mi->time;
hook.dwExtraInfo = mi->dwExtraInfo;
if (!HOOK_CallHooks( WH_MOUSE_LL, HC_ACTION, message, (LPARAM)&hook, TRUE ))
queue_hardware_message( message, (HWND)mi->dwExtraInfo /*FIXME*/,
MAKEWPARAM( get_key_state(), mi->mouseData ),
0, x, y, mi->time, mi->dwExtraInfo );
}
/***********************************************************************
* queue_mouse_event
*/
static void queue_mouse_event( const MOUSEINPUT *mi, UINT flags )
{
if (mi->dwFlags & MOUSEEVENTF_ABSOLUTE)
{
PosX = (mi->dx * GetSystemMetrics(SM_CXSCREEN)) >> 16;
PosY = (mi->dy * GetSystemMetrics(SM_CYSCREEN)) >> 16;
}
else if (mi->dwFlags & MOUSEEVENTF_MOVE)
{
int width = GetSystemMetrics(SM_CXSCREEN);
int height = GetSystemMetrics(SM_CYSCREEN);
long posX = (long) PosX, posY = (long) PosY;
int accel[3];
int accelMult;
/* dx and dy can be negative numbers for relative movements */
SystemParametersInfoA(SPI_GETMOUSE, 0, accel, 0);
accelMult = 1;
if (mi->dx > accel[0] && accel[2] != 0)
{
accelMult = 2;
if ((mi->dx > accel[1]) && (accel[2] == 2))
{
accelMult = 4;
}
}
posX += (long)mi->dx * accelMult;
accelMult = 1;
if (mi->dy > accel[0] && accel[2] != 0)
{
accelMult = 2;
if ((mi->dy > accel[1]) && (accel[2] == 2))
{
accelMult = 4;
}
}
posY += (long)mi->dy * accelMult;
/* Clip to the current screen size */
if (posX < 0) PosX = 0;
else if (posX >= width) PosX = width - 1;
else PosX = posX;
if (posY < 0) PosY = 0;
else if (posY >= height) PosY = height - 1;
else PosY = posY;
}
if (mi->dwFlags & MOUSEEVENTF_MOVE)
{
queue_raw_mouse_message( WM_MOUSEMOVE, flags, PosX, PosY, mi );
if (flags & LLMHF_INJECTED) /* we have to actually move the cursor */
SetCursorPos( PosX, PosY );
}
if (mi->dwFlags & MOUSEEVENTF_LEFTDOWN)
{
InputKeyStateTable[VK_LBUTTON] |= 0x80;
AsyncKeyStateTable[VK_LBUTTON] |= 0x80;
queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONDOWN : WM_LBUTTONDOWN,
flags, PosX, PosY, mi );
}
if (mi->dwFlags & MOUSEEVENTF_LEFTUP)
{
InputKeyStateTable[VK_LBUTTON] &= ~0x80;
queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONUP : WM_LBUTTONUP,
flags, PosX, PosY, mi );
}
if (mi->dwFlags & MOUSEEVENTF_RIGHTDOWN)
{
InputKeyStateTable[VK_RBUTTON] |= 0x80;
AsyncKeyStateTable[VK_RBUTTON] |= 0x80;
queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONDOWN : WM_RBUTTONDOWN,
flags, PosX, PosY, mi );
}
if (mi->dwFlags & MOUSEEVENTF_RIGHTUP)
{
InputKeyStateTable[VK_RBUTTON] &= ~0x80;
queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONUP : WM_RBUTTONUP,
flags, PosX, PosY, mi );
}
if (mi->dwFlags & MOUSEEVENTF_MIDDLEDOWN)
{
InputKeyStateTable[VK_MBUTTON] |= 0x80;
AsyncKeyStateTable[VK_MBUTTON] |= 0x80;
queue_raw_mouse_message( WM_MBUTTONDOWN, flags, PosX, PosY, mi );
}
if (mi->dwFlags & MOUSEEVENTF_MIDDLEUP)
{
InputKeyStateTable[VK_MBUTTON] &= ~0x80;
queue_raw_mouse_message( WM_MBUTTONUP, flags, PosX, PosY, mi );
}
if (mi->dwFlags & MOUSEEVENTF_WHEEL)
{
queue_raw_mouse_message( WM_MOUSEWHEEL, flags, PosX, PosY, mi );
}
}
/***********************************************************************
* SendInput (USER32.@)
*/
UINT WINAPI SendInput( UINT count, LPINPUT inputs, int size )
{
UINT i;
for (i = 0; i < count; i++, inputs++)
{
switch(inputs->type)
{
case INPUT_MOUSE:
queue_mouse_event( &inputs->u.mi, LLMHF_INJECTED );
break;
case WINE_INTERNAL_INPUT_MOUSE:
queue_mouse_event( &inputs->u.mi, 0 );
break;
case INPUT_KEYBOARD:
queue_kbd_event( &inputs->u.ki, LLKHF_INJECTED );
break;
case WINE_INTERNAL_INPUT_KEYBOARD:
queue_kbd_event( &inputs->u.ki, 0 );
break;
case INPUT_HARDWARE:
FIXME( "INPUT_HARDWARE not supported\n" );
break;
}
}
return count;
if (USER_Driver.pSendInput) return USER_Driver.pSendInput( count, inputs, size );
return 0;
}
@ -404,11 +128,8 @@ void WINAPI mouse_event( DWORD dwFlags, DWORD dx, DWORD dy,
*/
BOOL WINAPI GetCursorPos( POINT *pt )
{
if (!pt) return 0;
pt->x = PosX;
pt->y = PosY;
if (USER_Driver.pGetCursorPos) USER_Driver.pGetCursorPos( pt );
return 1;
if (pt && USER_Driver.pGetCursorPos) return USER_Driver.pGetCursorPos( pt );
return FALSE;
}
@ -432,10 +153,8 @@ BOOL WINAPI GetCursorInfo( PCURSORINFO pci )
*/
BOOL WINAPI SetCursorPos( INT x, INT y )
{
if (USER_Driver.pSetCursorPos) USER_Driver.pSetCursorPos( x, y );
PosX = x;
PosY = y;
return TRUE;
if (USER_Driver.pSetCursorPos) return USER_Driver.pSetCursorPos( x, y );
return FALSE;
}
@ -496,20 +215,11 @@ HWND WINAPI GetCapture(void)
* Determine if a key is or was pressed. retval has high-order
* bit set to 1 if currently pressed, low-order bit set to 1 if key has
* been pressed.
*
* This uses the variable AsyncMouseButtonsStates and
* AsyncKeyStateTable (set in event.c) which have the mouse button
* number or key number (whichever is applicable) set to true if the
* mouse or key had been depressed since the last call to
* GetAsyncKeyState.
*/
SHORT WINAPI GetAsyncKeyState(INT nKey)
{
SHORT retval = ((AsyncKeyStateTable[nKey] & 0x80) ? 0x0001 : 0) |
((InputKeyStateTable[nKey] & 0x80) ? 0x8000 : 0);
AsyncKeyStateTable[nKey] = 0;
TRACE_(key)("(%x) -> %x\n", nKey, retval);
return retval;
if (USER_Driver.pGetAsyncKeyState) return USER_Driver.pGetAsyncKeyState( nKey );
return 0;
}