4 * Copyright 1998 Ulrich Weigand
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #ifdef HAVE_LIBXXF86DGA2
25 #include <X11/extensions/xf86dga.h>
29 #define NONAMELESSUNION
30 #define NONAMELESSSTRUCT
33 #include "wine/winuser16.h"
37 #include "wine/server.h"
38 #include "wine/debug.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(cursor
);
42 /**********************************************************************/
45 #define Button6Mask (1<<13)
48 #define Button7Mask (1<<14)
51 #define NB_BUTTONS 7 /* Windows can handle 5 buttons and the wheel too */
53 static const UINT button_down_flags
[NB_BUTTONS
] =
56 MOUSEEVENTF_MIDDLEDOWN
,
57 MOUSEEVENTF_RIGHTDOWN
,
64 static const UINT button_up_flags
[NB_BUTTONS
] =
77 /***********************************************************************
80 * get the coordinates of a mouse event
82 static inline void get_coords( HWND hwnd
, int x
, int y
, POINT
*pt
)
84 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
88 pt
->x
= x
+ data
->whole_rect
.left
;
89 pt
->y
= y
+ data
->whole_rect
.top
;
93 /***********************************************************************
96 * Update the button state with what X provides us
98 static inline void update_button_state( unsigned int state
)
100 key_state_table
[VK_LBUTTON
] = (state
& Button1Mask
? 0x80 : 0);
101 key_state_table
[VK_MBUTTON
] = (state
& Button2Mask
? 0x80 : 0);
102 key_state_table
[VK_RBUTTON
] = (state
& Button3Mask
? 0x80 : 0);
103 key_state_table
[VK_XBUTTON1
]= (state
& Button6Mask
? 0x80 : 0);
104 key_state_table
[VK_XBUTTON2
]= (state
& Button7Mask
? 0x80 : 0);
108 /***********************************************************************
111 * Update the key state with what X provides us
113 static inline void update_key_state( unsigned int state
)
115 key_state_table
[VK_SHIFT
] = (state
& ShiftMask
? 0x80 : 0);
116 key_state_table
[VK_CONTROL
] = (state
& ControlMask
? 0x80 : 0);
120 /***********************************************************************
123 * Update the various window states on a mouse event.
125 static void update_mouse_state( HWND hwnd
, Window window
, int x
, int y
, unsigned int state
, POINT
*pt
)
127 struct x11drv_thread_data
*data
= x11drv_thread_data();
129 get_coords( hwnd
, x
, y
, pt
);
130 update_key_state( state
);
132 /* update the cursor */
134 if (data
->cursor_window
!= window
)
136 data
->cursor_window
= window
;
138 if (data
->cursor
) XDefineCursor( data
->display
, window
, data
->cursor
);
142 /* update the wine server Z-order */
144 if (window
!= data
->grab_window
&&
145 /* ignore event if a button is pressed, since the mouse is then grabbed too */
146 !(state
& (Button1Mask
|Button2Mask
|Button3Mask
|Button4Mask
|Button5Mask
|Button6Mask
|Button7Mask
)))
148 SERVER_START_REQ( update_window_zorder
)
151 req
->rect
.left
= pt
->x
;
152 req
->rect
.top
= pt
->y
;
153 req
->rect
.right
= pt
->x
+ 1;
154 req
->rect
.bottom
= pt
->y
+ 1;
155 wine_server_call( req
);
162 /***********************************************************************
165 static WORD
get_key_state(void)
169 if (GetSystemMetrics( SM_SWAPBUTTON
))
171 if (key_state_table
[VK_RBUTTON
] & 0x80) ret
|= MK_LBUTTON
;
172 if (key_state_table
[VK_LBUTTON
] & 0x80) ret
|= MK_RBUTTON
;
176 if (key_state_table
[VK_LBUTTON
] & 0x80) ret
|= MK_LBUTTON
;
177 if (key_state_table
[VK_RBUTTON
] & 0x80) ret
|= MK_RBUTTON
;
179 if (key_state_table
[VK_MBUTTON
] & 0x80) ret
|= MK_MBUTTON
;
180 if (key_state_table
[VK_SHIFT
] & 0x80) ret
|= MK_SHIFT
;
181 if (key_state_table
[VK_CONTROL
] & 0x80) ret
|= MK_CONTROL
;
182 if (key_state_table
[VK_XBUTTON1
] & 0x80) ret
|= MK_XBUTTON1
;
183 if (key_state_table
[VK_XBUTTON2
] & 0x80) ret
|= MK_XBUTTON2
;
188 /***********************************************************************
189 * queue_raw_mouse_message
191 static void queue_raw_mouse_message( UINT message
, HWND hwnd
, DWORD x
, DWORD y
,
192 DWORD data
, DWORD time
, DWORD extra_info
, UINT injected_flags
)
198 hook
.mouseData
= MAKELONG( 0, data
);
199 hook
.flags
= injected_flags
;
201 hook
.dwExtraInfo
= extra_info
;
203 if (HOOK_CallHooks( WH_MOUSE_LL
, HC_ACTION
, message
, (LPARAM
)&hook
, TRUE
)) return;
205 SERVER_START_REQ( send_message
)
207 req
->id
= (injected_flags
& LLMHF_INJECTED
) ? 0 : GetCurrentThreadId();
208 req
->type
= MSG_HARDWARE
;
212 req
->wparam
= MAKEWPARAM( get_key_state(), data
);
217 req
->info
= extra_info
;
219 req
->callback
= NULL
;
220 wine_server_call( req
);
227 /***********************************************************************
228 * X11DRV_send_mouse_input
230 void X11DRV_send_mouse_input( HWND hwnd
, DWORD flags
, DWORD x
, DWORD y
,
231 DWORD data
, DWORD time
, DWORD extra_info
, UINT injected_flags
)
235 if (flags
& MOUSEEVENTF_ABSOLUTE
)
237 if (injected_flags
& LLMHF_INJECTED
)
239 pt
.x
= (x
* screen_width
) >> 16;
240 pt
.y
= (y
* screen_height
) >> 16;
251 else if (flags
& MOUSEEVENTF_MOVE
)
253 int accel
[3], xMult
= 1, yMult
= 1;
255 /* dx and dy can be negative numbers for relative movements */
256 SystemParametersInfoW(SPI_GETMOUSE
, 0, accel
, 0);
258 if (x
> accel
[0] && accel
[2] != 0)
261 if ((x
> accel
[1]) && (accel
[2] == 2)) xMult
= 4;
263 if (y
> accel
[0] && accel
[2] != 0)
266 if ((y
> accel
[1]) && (accel
[2] == 2)) yMult
= 4;
270 pt
.x
= cursor_pos
.x
+ (long)x
* xMult
;
271 pt
.y
= cursor_pos
.y
+ (long)y
* yMult
;
273 /* Clip to the current screen size */
274 if (pt
.x
< 0) pt
.x
= 0;
275 else if (pt
.x
>= screen_width
) pt
.x
= screen_width
- 1;
276 if (pt
.y
< 0) pt
.y
= 0;
277 else if (pt
.y
>= screen_height
) pt
.y
= screen_height
- 1;
288 if (flags
& MOUSEEVENTF_MOVE
)
290 queue_raw_mouse_message( WM_MOUSEMOVE
, hwnd
, pt
.x
, pt
.y
, data
, time
,
291 extra_info
, injected_flags
);
292 if ((injected_flags
& LLMHF_INJECTED
) &&
293 ((flags
& MOUSEEVENTF_ABSOLUTE
) || x
|| y
)) /* we have to actually move the cursor */
295 TRACE( "warping to (%ld,%ld)\n", pt
.x
, pt
.y
);
297 XWarpPointer( thread_display(), root_window
, root_window
, 0, 0, 0, 0, pt
.x
, pt
.y
);
301 if (flags
& MOUSEEVENTF_LEFTDOWN
)
303 key_state_table
[VK_LBUTTON
] |= 0xc0;
304 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON
) ? WM_RBUTTONDOWN
: WM_LBUTTONDOWN
,
305 hwnd
, pt
.x
, pt
.y
, data
, time
, extra_info
, injected_flags
);
307 if (flags
& MOUSEEVENTF_LEFTUP
)
309 key_state_table
[VK_LBUTTON
] &= ~0x80;
310 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON
) ? WM_RBUTTONUP
: WM_LBUTTONUP
,
311 hwnd
, pt
.x
, pt
.y
, data
, time
, extra_info
, injected_flags
);
313 if (flags
& MOUSEEVENTF_RIGHTDOWN
)
315 key_state_table
[VK_RBUTTON
] |= 0xc0;
316 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON
) ? WM_LBUTTONDOWN
: WM_RBUTTONDOWN
,
317 hwnd
, pt
.x
, pt
.y
, data
, time
, extra_info
, injected_flags
);
319 if (flags
& MOUSEEVENTF_RIGHTUP
)
321 key_state_table
[VK_RBUTTON
] &= ~0x80;
322 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON
) ? WM_LBUTTONUP
: WM_RBUTTONUP
,
323 hwnd
, pt
.x
, pt
.y
, data
, time
, extra_info
, injected_flags
);
325 if (flags
& MOUSEEVENTF_MIDDLEDOWN
)
327 key_state_table
[VK_MBUTTON
] |= 0xc0;
328 queue_raw_mouse_message( WM_MBUTTONDOWN
, hwnd
, pt
.x
, pt
.y
, data
, time
,
329 extra_info
, injected_flags
);
331 if (flags
& MOUSEEVENTF_MIDDLEUP
)
333 key_state_table
[VK_MBUTTON
] &= ~0x80;
334 queue_raw_mouse_message( WM_MBUTTONUP
, hwnd
, pt
.x
, pt
.y
, data
, time
,
335 extra_info
, injected_flags
);
337 if (flags
& MOUSEEVENTF_WHEEL
)
339 queue_raw_mouse_message( WM_MOUSEWHEEL
, hwnd
, pt
.x
, pt
.y
, data
, time
,
340 extra_info
, injected_flags
);
342 if (flags
& MOUSEEVENTF_XDOWN
)
344 key_state_table
[VK_XBUTTON1
+ data
- 1] |= 0xc0;
345 queue_raw_mouse_message( WM_XBUTTONDOWN
, hwnd
, pt
.x
, pt
.y
, data
, time
,
346 extra_info
, injected_flags
);
348 if (flags
& MOUSEEVENTF_XUP
)
350 key_state_table
[VK_XBUTTON1
+ data
- 1] &= ~0x80;
351 queue_raw_mouse_message( WM_XBUTTONUP
, hwnd
, pt
.x
, pt
.y
, data
, time
,
352 extra_info
, injected_flags
);
357 /***********************************************************************
360 * Create an X cursor from a Windows one.
362 static Cursor
create_cursor( Display
*display
, CURSORICONINFO
*ptr
)
364 Pixmap pixmapBits
, pixmapMask
, pixmapMaskInv
, pixmapAll
;
366 Cursor cursor
= None
;
368 if (!ptr
) /* Create an empty cursor */
370 static const char data
[] = { 0 };
372 bg
.red
= bg
.green
= bg
.blue
= 0x0000;
373 pixmapBits
= XCreateBitmapFromData( display
, root_window
, data
, 1, 1 );
376 cursor
= XCreatePixmapCursor( display
, pixmapBits
, pixmapBits
,
378 XFreePixmap( display
, pixmapBits
);
381 else /* Create the X cursor from the bits */
386 TRACE("Bitmap %dx%d planes=%d bpp=%d bytesperline=%d\n",
387 ptr
->nWidth
, ptr
->nHeight
, ptr
->bPlanes
, ptr
->bBitsPerPixel
,
389 /* Create a pixmap and transfer all the bits to it */
391 /* NOTE: Following hack works, but only because XFree depth
392 * 1 images really use 1 bit/pixel (and so the same layout
393 * as the Windows cursor data). Perhaps use a more generic
396 /* This pixmap will be written with two bitmaps. The first is
397 * the mask and the second is the image.
399 if (!(pixmapAll
= XCreatePixmap( display
, root_window
,
400 ptr
->nWidth
, ptr
->nHeight
* 2, 1 )))
402 if (!(image
= XCreateImage( display
, visual
,
403 1, ZPixmap
, 0, (char *)(ptr
+ 1), ptr
->nWidth
,
404 ptr
->nHeight
* 2, 16, ptr
->nWidthBytes
/ptr
->bBitsPerPixel
)))
406 XFreePixmap( display
, pixmapAll
);
409 gc
= XCreateGC( display
, pixmapAll
, 0, NULL
);
410 XSetGraphicsExposures( display
, gc
, False
);
411 image
->byte_order
= MSBFirst
;
412 image
->bitmap_bit_order
= MSBFirst
;
413 image
->bitmap_unit
= 16;
414 _XInitImageFuncPtrs(image
);
415 if (ptr
->bPlanes
* ptr
->bBitsPerPixel
== 1)
417 /* A plain old white on black cursor. */
418 fg
.red
= fg
.green
= fg
.blue
= 0xffff;
419 bg
.red
= bg
.green
= bg
.blue
= 0x0000;
420 XPutImage( display
, pixmapAll
, gc
, image
,
421 0, 0, 0, 0, ptr
->nWidth
, ptr
->nHeight
* 2 );
425 int rbits
, gbits
, bbits
, red
, green
, blue
;
426 int rfg
, gfg
, bfg
, rbg
, gbg
, bbg
;
427 int rscale
, gscale
, bscale
;
428 int x
, y
, xmax
, ymax
, bitIndex
, byteIndex
, xorIndex
;
429 unsigned char *theMask
, *theImage
, theChar
;
430 int threshold
, fgBits
, bgBits
, bitShifted
;
431 BYTE pXorBits
[128]; /* Up to 32x32 icons */
433 switch (ptr
->bBitsPerPixel
)
448 FIXME("Currently no support for cursors with %d bits per pixel\n",
450 XFreePixmap( display
, pixmapAll
);
451 XFreeGC( display
, gc
);
453 XDestroyImage( image
);
456 /* The location of the mask. */
457 theMask
= (unsigned char *)(ptr
+ 1);
458 /* The mask should still be 1 bit per pixel. The color image
459 * should immediately follow the mask.
461 theImage
= &theMask
[ptr
->nWidth
/8 * ptr
->nHeight
];
462 rfg
= gfg
= bfg
= rbg
= gbg
= bbg
= 0;
468 xmax
= (ptr
->nWidth
> 32) ? 32 : ptr
->nWidth
;
469 if (ptr
->nWidth
> 32) {
470 ERR("Got a %dx%d cursor. Cannot handle larger than 32x32.\n",
471 ptr
->nWidth
, ptr
->nHeight
);
473 ymax
= (ptr
->nHeight
> 32) ? 32 : ptr
->nHeight
;
475 memset(pXorBits
, 0, 128);
476 for (y
=0; y
<ymax
; y
++)
478 for (x
=0; x
<xmax
; x
++)
480 red
= green
= blue
= 0;
481 switch (ptr
->bBitsPerPixel
)
484 theChar
= theImage
[byteIndex
++];
486 theChar
= theImage
[byteIndex
++];
488 theChar
= theImage
[byteIndex
++];
492 theChar
= theImage
[byteIndex
++];
493 blue
= theChar
& 0x1F;
494 green
= (theChar
& 0xE0) >> 5;
495 theChar
= theImage
[byteIndex
++];
496 green
|= (theChar
& 0x07) << 3;
497 red
= (theChar
& 0xF8) >> 3;
501 if (red
+green
+blue
> threshold
)
507 pXorBits
[xorIndex
] |= bitShifted
;
521 bitShifted
= bitShifted
<< 1;
524 rscale
= 1 << (16 - rbits
);
525 gscale
= 1 << (16 - gbits
);
526 bscale
= 1 << (16 - bbits
);
529 fg
.red
= rfg
* rscale
/ fgBits
;
530 fg
.green
= gfg
* gscale
/ fgBits
;
531 fg
.blue
= bfg
* bscale
/ fgBits
;
533 else fg
.red
= fg
.green
= fg
.blue
= 0;
534 bgBits
= xmax
* ymax
- fgBits
;
537 bg
.red
= rbg
* rscale
/ bgBits
;
538 bg
.green
= gbg
* gscale
/ bgBits
;
539 bg
.blue
= bbg
* bscale
/ bgBits
;
541 else bg
.red
= bg
.green
= bg
.blue
= 0;
542 pixmapBits
= XCreateBitmapFromData( display
, root_window
, (char *)pXorBits
, xmax
, ymax
);
545 XFreePixmap( display
, pixmapAll
);
546 XFreeGC( display
, gc
);
548 XDestroyImage( image
);
553 XPutImage( display
, pixmapAll
, gc
, image
,
554 0, 0, 0, 0, ptr
->nWidth
, ptr
->nHeight
);
555 XSetFunction( display
, gc
, GXcopy
);
557 XCopyArea( display
, pixmapBits
, pixmapAll
, gc
,
558 0, 0, xmax
, ymax
, 0, ptr
->nHeight
);
559 XFreePixmap( display
, pixmapBits
);
562 XDestroyImage( image
);
564 /* Now create the 2 pixmaps for bits and mask */
566 pixmapBits
= XCreatePixmap( display
, root_window
, ptr
->nWidth
, ptr
->nHeight
, 1 );
567 pixmapMask
= XCreatePixmap( display
, root_window
, ptr
->nWidth
, ptr
->nHeight
, 1 );
568 pixmapMaskInv
= XCreatePixmap( display
, root_window
, ptr
->nWidth
, ptr
->nHeight
, 1 );
570 /* Make sure everything went OK so far */
572 if (pixmapBits
&& pixmapMask
&& pixmapMaskInv
)
576 /* We have to do some magic here, as cursors are not fully
577 * compatible between Windows and X11. Under X11, there
578 * are only 3 possible color cursor: black, white and
579 * masked. So we map the 4th Windows color (invert the
580 * bits on the screen) to black and an additional white bit on
581 * an other place (+1,+1). This require some boolean arithmetic:
584 * And Xor Result | Bits Mask Result
585 * 0 0 black | 0 1 background
586 * 0 1 white | 1 1 foreground
587 * 1 0 no change | X 0 no change
588 * 1 1 inverted | 0 1 background
591 * Bits = not 'And' and 'Xor' or 'And2' and 'Xor2'
592 * Mask = not 'And' or 'Xor' or 'And2' and 'Xor2'
594 * FIXME: apparently some servers do support 'inverted' color.
595 * I don't know if it's correct per the X spec, but maybe
596 * we ought to take advantage of it. -- AJ
598 XSetFunction( display
, gc
, GXcopy
);
599 XCopyArea( display
, pixmapAll
, pixmapBits
, gc
,
600 0, 0, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
601 XCopyArea( display
, pixmapAll
, pixmapMask
, gc
,
602 0, 0, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
603 XCopyArea( display
, pixmapAll
, pixmapMaskInv
, gc
,
604 0, 0, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
605 XSetFunction( display
, gc
, GXand
);
606 XCopyArea( display
, pixmapAll
, pixmapMaskInv
, gc
,
607 0, ptr
->nHeight
, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
608 XSetFunction( display
, gc
, GXandReverse
);
609 XCopyArea( display
, pixmapAll
, pixmapBits
, gc
,
610 0, ptr
->nHeight
, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
611 XSetFunction( display
, gc
, GXorReverse
);
612 XCopyArea( display
, pixmapAll
, pixmapMask
, gc
,
613 0, ptr
->nHeight
, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
614 /* Additional white */
615 XSetFunction( display
, gc
, GXor
);
616 XCopyArea( display
, pixmapMaskInv
, pixmapMask
, gc
,
617 0, 0, ptr
->nWidth
, ptr
->nHeight
, 1, 1 );
618 XCopyArea( display
, pixmapMaskInv
, pixmapBits
, gc
,
619 0, 0, ptr
->nWidth
, ptr
->nHeight
, 1, 1 );
620 XSetFunction( display
, gc
, GXcopy
);
622 /* Make sure hotspot is valid */
623 hotspot
.x
= ptr
->ptHotSpot
.x
;
624 hotspot
.y
= ptr
->ptHotSpot
.y
;
625 if (hotspot
.x
< 0 || hotspot
.x
>= ptr
->nWidth
||
626 hotspot
.y
< 0 || hotspot
.y
>= ptr
->nHeight
)
628 hotspot
.x
= ptr
->nWidth
/ 2;
629 hotspot
.y
= ptr
->nHeight
/ 2;
631 cursor
= XCreatePixmapCursor( display
, pixmapBits
, pixmapMask
,
632 &fg
, &bg
, hotspot
.x
, hotspot
.y
);
635 /* Now free everything */
637 if (pixmapAll
) XFreePixmap( display
, pixmapAll
);
638 if (pixmapBits
) XFreePixmap( display
, pixmapBits
);
639 if (pixmapMask
) XFreePixmap( display
, pixmapMask
);
640 if (pixmapMaskInv
) XFreePixmap( display
, pixmapMaskInv
);
641 XFreeGC( display
, gc
);
647 /***********************************************************************
648 * SetCursor (X11DRV.@)
650 void X11DRV_SetCursor( CURSORICONINFO
*lpCursor
)
654 if (root_window
!= DefaultRootWindow(gdi_display
))
656 /* If in desktop mode, set the cursor on the desktop window */
659 cursor
= create_cursor( gdi_display
, lpCursor
);
662 XDefineCursor( gdi_display
, root_window
, cursor
);
663 /* Make the change take effect immediately */
665 XFreeCursor( gdi_display
, cursor
);
669 else /* set the same cursor for all top-level windows of the current thread */
671 struct x11drv_thread_data
*data
= x11drv_thread_data();
674 cursor
= create_cursor( data
->display
, lpCursor
);
677 if (data
->cursor
) XFreeCursor( data
->display
, data
->cursor
);
678 data
->cursor
= cursor
;
679 if (data
->cursor_window
)
681 XDefineCursor( data
->display
, data
->cursor_window
, cursor
);
682 /* Make the change take effect immediately */
683 XFlush( data
->display
);
690 /***********************************************************************
691 * SetCursorPos (X11DRV.@)
693 BOOL
X11DRV_SetCursorPos( INT x
, INT y
)
695 Display
*display
= thread_display();
697 TRACE( "warping to (%d,%d)\n", x
, y
);
700 XWarpPointer( display
, root_window
, root_window
, 0, 0, 0, 0, x
, y
);
701 XFlush( display
); /* avoids bad mouse lag in games that do their own mouse warping */
708 /***********************************************************************
709 * GetCursorPos (X11DRV.@)
711 BOOL
X11DRV_GetCursorPos(LPPOINT pos
)
713 Display
*display
= thread_display();
715 int rootX
, rootY
, winX
, winY
;
719 if (XQueryPointer( display
, root_window
, &root
, &child
,
720 &rootX
, &rootY
, &winX
, &winY
, &xstate
))
722 update_key_state( xstate
);
723 update_button_state( xstate
);
724 TRACE("pointer at (%d,%d)\n", winX
, winY
);
733 /***********************************************************************
736 void X11DRV_ButtonPress( HWND hwnd
, XEvent
*xev
)
738 XButtonEvent
*event
= &xev
->xbutton
;
739 int buttonNum
= event
->button
- 1;
743 if (buttonNum
>= NB_BUTTONS
) return;
752 wData
= -WHEEL_DELTA
;
762 update_mouse_state( hwnd
, event
->window
, event
->x
, event
->y
, event
->state
, &pt
);
764 X11DRV_send_mouse_input( hwnd
, button_down_flags
[buttonNum
] | MOUSEEVENTF_ABSOLUTE
,
765 pt
.x
, pt
.y
, wData
, EVENT_x11_time_to_win32_time(event
->time
), 0, 0 );
769 /***********************************************************************
770 * X11DRV_ButtonRelease
772 void X11DRV_ButtonRelease( HWND hwnd
, XEvent
*xev
)
774 XButtonEvent
*event
= &xev
->xbutton
;
775 int buttonNum
= event
->button
- 1;
779 if (buttonNum
>= NB_BUTTONS
|| !button_up_flags
[buttonNum
]) return;
792 update_mouse_state( hwnd
, event
->window
, event
->x
, event
->y
, event
->state
, &pt
);
794 X11DRV_send_mouse_input( hwnd
, button_up_flags
[buttonNum
] | MOUSEEVENTF_ABSOLUTE
,
795 pt
.x
, pt
.y
, wData
, EVENT_x11_time_to_win32_time(event
->time
), 0, 0 );
799 /***********************************************************************
800 * X11DRV_MotionNotify
802 void X11DRV_MotionNotify( HWND hwnd
, XEvent
*xev
)
804 XMotionEvent
*event
= &xev
->xmotion
;
807 TRACE("hwnd %p, event->is_hint %d\n", hwnd
, event
->is_hint
);
811 update_mouse_state( hwnd
, event
->window
, event
->x
, event
->y
, event
->state
, &pt
);
813 X11DRV_send_mouse_input( hwnd
, MOUSEEVENTF_MOVE
| MOUSEEVENTF_ABSOLUTE
,
814 pt
.x
, pt
.y
, 0, EVENT_x11_time_to_win32_time(event
->time
), 0, 0 );
818 /***********************************************************************
821 void X11DRV_EnterNotify( HWND hwnd
, XEvent
*xev
)
823 XCrossingEvent
*event
= &xev
->xcrossing
;
826 TRACE("hwnd %p, event->detail %d\n", hwnd
, event
->detail
);
829 if (event
->detail
== NotifyVirtual
|| event
->detail
== NotifyNonlinearVirtual
) return;
831 /* simulate a mouse motion event */
832 update_mouse_state( hwnd
, event
->window
, event
->x
, event
->y
, event
->state
, &pt
);
834 X11DRV_send_mouse_input( hwnd
, MOUSEEVENTF_MOVE
| MOUSEEVENTF_ABSOLUTE
,
835 pt
.x
, pt
.y
, 0, EVENT_x11_time_to_win32_time(event
->time
), 0, 0 );
839 #ifdef HAVE_LIBXXF86DGA2
843 /**********************************************************************
844 * X11DRV_DGAMotionEvent
846 void X11DRV_DGAMotionEvent( HWND hwnd
, XEvent
*xev
)
848 XDGAMotionEvent
*event
= (XDGAMotionEvent
*)xev
;
849 update_key_state( event
->state
);
850 X11DRV_send_mouse_input( DGAhwnd
, MOUSEEVENTF_MOVE
, event
->dx
, event
->dy
,
851 0, EVENT_x11_time_to_win32_time(event
->time
), 0, 0 );
854 /**********************************************************************
855 * X11DRV_DGAButtonPressEvent
857 void X11DRV_DGAButtonPressEvent( HWND hwnd
, XEvent
*xev
)
859 XDGAButtonEvent
*event
= (XDGAButtonEvent
*)xev
;
860 int buttonNum
= event
->button
- 1;
862 if (buttonNum
>= NB_BUTTONS
) return;
863 update_key_state( event
->state
);
864 X11DRV_send_mouse_input( DGAhwnd
, button_down_flags
[buttonNum
], 0, 0,
865 0, EVENT_x11_time_to_win32_time(event
->time
), 0, 0 );
868 /**********************************************************************
869 * X11DRV_DGAButtonReleaseEvent
871 void X11DRV_DGAButtonReleaseEvent( HWND hwnd
, XEvent
*xev
)
873 XDGAButtonEvent
*event
= (XDGAButtonEvent
*)xev
;
874 int buttonNum
= event
->button
- 1;
876 if (buttonNum
>= NB_BUTTONS
) return;
877 update_key_state( event
->state
);
878 X11DRV_send_mouse_input( DGAhwnd
, button_up_flags
[buttonNum
], 0, 0,
879 0, EVENT_x11_time_to_win32_time(event
->time
), 0, 0 );
882 #endif /* HAVE_LIBXXF86DGA2 */