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"
36 #include "wine/debug.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(cursor
);
40 /**********************************************************************/
42 #define NB_BUTTONS 5 /* Windows can handle 3 buttons and the wheel too */
44 static const UINT button_down_flags
[NB_BUTTONS
] =
47 MOUSEEVENTF_MIDDLEDOWN
,
48 MOUSEEVENTF_RIGHTDOWN
,
53 static const UINT button_up_flags
[NB_BUTTONS
] =
62 static BYTE
*pKeyStateTable
;
65 /***********************************************************************
68 * get the coordinates of a mouse event
70 static void get_coords( HWND
*hwnd
, Window window
, int x
, int y
, POINT
*pt
)
72 struct x11drv_win_data
*data
;
75 if (!(win
= WIN_GetPtr( *hwnd
)) || win
== WND_OTHER_PROCESS
) return;
76 data
= win
->pDriverData
;
78 if (window
== data
->whole_window
)
80 x
-= data
->client_rect
.left
;
81 y
-= data
->client_rect
.top
;
83 WIN_ReleasePtr( win
);
87 if (*hwnd
!= GetDesktopWindow())
89 ClientToScreen( *hwnd
, pt
);
90 *hwnd
= GetAncestor( *hwnd
, GA_ROOT
);
95 /***********************************************************************
98 * Update the button state with what X provides us
100 static void update_button_state( unsigned int state
)
102 pKeyStateTable
[VK_LBUTTON
] = (state
& Button1Mask
? 0x80 : 0);
103 pKeyStateTable
[VK_MBUTTON
] = (state
& Button2Mask
? 0x80 : 0);
104 pKeyStateTable
[VK_RBUTTON
] = (state
& Button3Mask
? 0x80 : 0);
108 /***********************************************************************
111 * Update the key state with what X provides us
113 static void update_key_state( unsigned int state
)
115 pKeyStateTable
[VK_SHIFT
] = (state
& ShiftMask
? 0x80 : 0);
116 pKeyStateTable
[VK_CONTROL
] = (state
& ControlMask
? 0x80 : 0);
120 /***********************************************************************
123 static void send_mouse_event( HWND hwnd
, DWORD flags
, DWORD posX
, DWORD posY
,
124 DWORD data
, Time time
)
128 TRACE("(%04lX,%ld,%ld)\n", flags
, posX
, posY
);
130 if (flags
& MOUSEEVENTF_ABSOLUTE
)
132 int width
= GetSystemMetrics( SM_CXSCREEN
);
133 int height
= GetSystemMetrics( SM_CYSCREEN
);
134 /* Relative mouse movements seem not to be scaled as absolute ones */
135 posX
= (((long)posX
<< 16) + width
-1) / width
;
136 posY
= (((long)posY
<< 16) + height
-1) / height
;
139 input
.type
= WINE_INTERNAL_INPUT_MOUSE
;
140 input
.u
.mi
.dx
= posX
;
141 input
.u
.mi
.dy
= posY
;
142 input
.u
.mi
.mouseData
= data
;
143 input
.u
.mi
.dwFlags
= flags
;
144 input
.u
.mi
.time
= time
- X11DRV_server_startticks
;
145 input
.u
.mi
.dwExtraInfo
= (ULONG_PTR
)hwnd
;
146 SendInput( 1, &input
, sizeof(input
) );
150 /***********************************************************************
153 * Update the cursor of a window on a mouse event.
155 static void update_cursor( HWND hwnd
, Window win
)
157 struct x11drv_thread_data
*data
= x11drv_thread_data();
159 if (win
== X11DRV_get_client_window( hwnd
))
160 win
= X11DRV_get_whole_window( hwnd
); /* always set cursor on whole window */
162 if (data
->cursor_window
!= win
)
164 data
->cursor_window
= win
;
165 if (data
->cursor
) TSXDefineCursor( data
->display
, win
, data
->cursor
);
170 /***********************************************************************
173 * Create an X cursor from a Windows one.
175 static Cursor
create_cursor( Display
*display
, CURSORICONINFO
*ptr
)
177 Pixmap pixmapBits
, pixmapMask
, pixmapMaskInv
, pixmapAll
;
179 Cursor cursor
= None
;
181 if (!ptr
) /* Create an empty cursor */
183 static const char data
[] = { 0 };
185 bg
.red
= bg
.green
= bg
.blue
= 0x0000;
186 pixmapBits
= XCreateBitmapFromData( display
, root_window
, data
, 1, 1 );
189 cursor
= XCreatePixmapCursor( display
, pixmapBits
, pixmapBits
,
191 XFreePixmap( display
, pixmapBits
);
194 else /* Create the X cursor from the bits */
199 TRACE("Bitmap %dx%d planes=%d bpp=%d bytesperline=%d\n",
200 ptr
->nWidth
, ptr
->nHeight
, ptr
->bPlanes
, ptr
->bBitsPerPixel
,
202 /* Create a pixmap and transfer all the bits to it */
204 /* NOTE: Following hack works, but only because XFree depth
205 * 1 images really use 1 bit/pixel (and so the same layout
206 * as the Windows cursor data). Perhaps use a more generic
209 /* This pixmap will be written with two bitmaps. The first is
210 * the mask and the second is the image.
212 if (!(pixmapAll
= XCreatePixmap( display
, root_window
,
213 ptr
->nWidth
, ptr
->nHeight
* 2, 1 )))
215 if (!(image
= XCreateImage( display
, visual
,
216 1, ZPixmap
, 0, (char *)(ptr
+ 1), ptr
->nWidth
,
217 ptr
->nHeight
* 2, 16, ptr
->nWidthBytes
/ptr
->bBitsPerPixel
)))
219 XFreePixmap( display
, pixmapAll
);
222 gc
= XCreateGC( display
, pixmapAll
, 0, NULL
);
223 XSetGraphicsExposures( display
, gc
, False
);
224 image
->byte_order
= MSBFirst
;
225 image
->bitmap_bit_order
= MSBFirst
;
226 image
->bitmap_unit
= 16;
227 _XInitImageFuncPtrs(image
);
228 if (ptr
->bPlanes
* ptr
->bBitsPerPixel
== 1)
230 /* A plain old white on black cursor. */
231 fg
.red
= fg
.green
= fg
.blue
= 0xffff;
232 bg
.red
= bg
.green
= bg
.blue
= 0x0000;
233 XPutImage( display
, pixmapAll
, gc
, image
,
234 0, 0, 0, 0, ptr
->nWidth
, ptr
->nHeight
* 2 );
238 int rbits
, gbits
, bbits
, red
, green
, blue
;
239 int rfg
, gfg
, bfg
, rbg
, gbg
, bbg
;
240 int rscale
, gscale
, bscale
;
241 int x
, y
, xmax
, ymax
, bitIndex
, byteIndex
, xorIndex
;
242 unsigned char *theMask
, *theImage
, theChar
;
243 int threshold
, fgBits
, bgBits
, bitShifted
;
244 BYTE pXorBits
[128]; /* Up to 32x32 icons */
246 switch (ptr
->bBitsPerPixel
)
261 FIXME("Currently no support for cursors with %d bits per pixel\n",
263 XFreePixmap( display
, pixmapAll
);
264 XFreeGC( display
, gc
);
266 XDestroyImage( image
);
269 /* The location of the mask. */
270 theMask
= (char *)(ptr
+ 1);
271 /* The mask should still be 1 bit per pixel. The color image
272 * should immediately follow the mask.
274 theImage
= &theMask
[ptr
->nWidth
/8 * ptr
->nHeight
];
275 rfg
= gfg
= bfg
= rbg
= gbg
= bbg
= 0;
281 xmax
= (ptr
->nWidth
> 32) ? 32 : ptr
->nWidth
;
282 if (ptr
->nWidth
> 32) {
283 ERR("Got a %dx%d cursor. Cannot handle larger than 32x32.\n",
284 ptr
->nWidth
, ptr
->nHeight
);
286 ymax
= (ptr
->nHeight
> 32) ? 32 : ptr
->nHeight
;
288 memset(pXorBits
, 0, 128);
289 for (y
=0; y
<ymax
; y
++)
291 for (x
=0; x
<xmax
; x
++)
293 red
= green
= blue
= 0;
294 switch (ptr
->bBitsPerPixel
)
297 theChar
= theImage
[byteIndex
++];
299 theChar
= theImage
[byteIndex
++];
301 theChar
= theImage
[byteIndex
++];
305 theChar
= theImage
[byteIndex
++];
306 blue
= theChar
& 0x1F;
307 green
= (theChar
& 0xE0) >> 5;
308 theChar
= theImage
[byteIndex
++];
309 green
|= (theChar
& 0x07) << 3;
310 red
= (theChar
& 0xF8) >> 3;
314 if (red
+green
+blue
> threshold
)
320 pXorBits
[xorIndex
] |= bitShifted
;
334 bitShifted
= bitShifted
<< 1;
337 rscale
= 1 << (16 - rbits
);
338 gscale
= 1 << (16 - gbits
);
339 bscale
= 1 << (16 - bbits
);
342 fg
.red
= rfg
* rscale
/ fgBits
;
343 fg
.green
= gfg
* gscale
/ fgBits
;
344 fg
.blue
= bfg
* bscale
/ fgBits
;
346 else fg
.red
= fg
.green
= fg
.blue
= 0;
347 bgBits
= xmax
* ymax
- fgBits
;
350 bg
.red
= rbg
* rscale
/ bgBits
;
351 bg
.green
= gbg
* gscale
/ bgBits
;
352 bg
.blue
= bbg
* bscale
/ bgBits
;
354 else bg
.red
= bg
.green
= bg
.blue
= 0;
355 pixmapBits
= XCreateBitmapFromData( display
, root_window
, pXorBits
, xmax
, ymax
);
358 XFreePixmap( display
, pixmapAll
);
359 XFreeGC( display
, gc
);
361 XDestroyImage( image
);
366 XPutImage( display
, pixmapAll
, gc
, image
,
367 0, 0, 0, 0, ptr
->nWidth
, ptr
->nHeight
);
368 XSetFunction( display
, gc
, GXcopy
);
370 XCopyArea( display
, pixmapBits
, pixmapAll
, gc
,
371 0, 0, xmax
, ymax
, 0, ptr
->nHeight
);
372 XFreePixmap( display
, pixmapBits
);
375 XDestroyImage( image
);
377 /* Now create the 2 pixmaps for bits and mask */
379 pixmapBits
= XCreatePixmap( display
, root_window
, ptr
->nWidth
, ptr
->nHeight
, 1 );
380 pixmapMask
= XCreatePixmap( display
, root_window
, ptr
->nWidth
, ptr
->nHeight
, 1 );
381 pixmapMaskInv
= XCreatePixmap( display
, root_window
, ptr
->nWidth
, ptr
->nHeight
, 1 );
383 /* Make sure everything went OK so far */
385 if (pixmapBits
&& pixmapMask
&& pixmapMaskInv
)
389 /* We have to do some magic here, as cursors are not fully
390 * compatible between Windows and X11. Under X11, there
391 * are only 3 possible color cursor: black, white and
392 * masked. So we map the 4th Windows color (invert the
393 * bits on the screen) to black and an additional white bit on
394 * an other place (+1,+1). This require some boolean arithmetic:
397 * And Xor Result | Bits Mask Result
398 * 0 0 black | 0 1 background
399 * 0 1 white | 1 1 foreground
400 * 1 0 no change | X 0 no change
401 * 1 1 inverted | 0 1 background
404 * Bits = not 'And' and 'Xor' or 'And2' and 'Xor2'
405 * Mask = not 'And' or 'Xor' or 'And2' and 'Xor2'
407 * FIXME: apparently some servers do support 'inverted' color.
408 * I don't know if it's correct per the X spec, but maybe
409 * we ought to take advantage of it. -- AJ
411 XSetFunction( display
, gc
, GXcopy
);
412 XCopyArea( display
, pixmapAll
, pixmapBits
, gc
,
413 0, 0, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
414 XCopyArea( display
, pixmapAll
, pixmapMask
, gc
,
415 0, 0, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
416 XCopyArea( display
, pixmapAll
, pixmapMaskInv
, gc
,
417 0, 0, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
418 XSetFunction( display
, gc
, GXand
);
419 XCopyArea( display
, pixmapAll
, pixmapMaskInv
, gc
,
420 0, ptr
->nHeight
, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
421 XSetFunction( display
, gc
, GXandReverse
);
422 XCopyArea( display
, pixmapAll
, pixmapBits
, gc
,
423 0, ptr
->nHeight
, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
424 XSetFunction( display
, gc
, GXorReverse
);
425 XCopyArea( display
, pixmapAll
, pixmapMask
, gc
,
426 0, ptr
->nHeight
, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
427 /* Additional white */
428 XSetFunction( display
, gc
, GXor
);
429 XCopyArea( display
, pixmapMaskInv
, pixmapMask
, gc
,
430 0, 0, ptr
->nWidth
, ptr
->nHeight
, 1, 1 );
431 XCopyArea( display
, pixmapMaskInv
, pixmapBits
, gc
,
432 0, 0, ptr
->nWidth
, ptr
->nHeight
, 1, 1 );
433 XSetFunction( display
, gc
, GXcopy
);
435 /* Make sure hotspot is valid */
436 hotspot
.x
= ptr
->ptHotSpot
.x
;
437 hotspot
.y
= ptr
->ptHotSpot
.y
;
438 if (hotspot
.x
< 0 || hotspot
.x
>= ptr
->nWidth
||
439 hotspot
.y
< 0 || hotspot
.y
>= ptr
->nHeight
)
441 hotspot
.x
= ptr
->nWidth
/ 2;
442 hotspot
.y
= ptr
->nHeight
/ 2;
444 cursor
= XCreatePixmapCursor( display
, pixmapBits
, pixmapMask
,
445 &fg
, &bg
, hotspot
.x
, hotspot
.y
);
448 /* Now free everything */
450 if (pixmapAll
) XFreePixmap( display
, pixmapAll
);
451 if (pixmapBits
) XFreePixmap( display
, pixmapBits
);
452 if (pixmapMask
) XFreePixmap( display
, pixmapMask
);
453 if (pixmapMaskInv
) XFreePixmap( display
, pixmapMaskInv
);
454 XFreeGC( display
, gc
);
460 /***********************************************************************
461 * SetCursor (X11DRV.@)
463 void X11DRV_SetCursor( CURSORICONINFO
*lpCursor
)
467 if (root_window
!= DefaultRootWindow(gdi_display
))
469 /* If in desktop mode, set the cursor on the desktop window */
472 cursor
= create_cursor( gdi_display
, lpCursor
);
475 XDefineCursor( gdi_display
, root_window
, cursor
);
476 /* Make the change take effect immediately */
478 XFreeCursor( gdi_display
, cursor
);
482 else /* set the same cursor for all top-level windows of the current thread */
484 struct x11drv_thread_data
*data
= x11drv_thread_data();
487 cursor
= create_cursor( data
->display
, lpCursor
);
490 if (data
->cursor
) XFreeCursor( data
->display
, data
->cursor
);
491 data
->cursor
= cursor
;
492 if (data
->cursor_window
)
494 XDefineCursor( data
->display
, data
->cursor_window
, cursor
);
495 /* Make the change take effect immediately */
496 XFlush( data
->display
);
503 /***********************************************************************
504 * SetCursorPos (X11DRV.@)
506 void X11DRV_SetCursorPos( INT x
, INT y
)
508 Display
*display
= thread_display();
510 TRACE( "warping to (%d,%d)\n", x
, y
);
513 XWarpPointer( display
, root_window
, root_window
, 0, 0, 0, 0, x
, y
);
514 XFlush( display
); /* just in case */
518 /***********************************************************************
519 * GetCursorPos (X11DRV.@)
521 void X11DRV_GetCursorPos(LPPOINT pos
)
523 Display
*display
= thread_display();
525 int rootX
, rootY
, winX
, winY
;
528 if (!TSXQueryPointer( display
, root_window
, &root
, &child
,
529 &rootX
, &rootY
, &winX
, &winY
, &xstate
))
532 update_key_state( xstate
);
533 update_button_state( xstate
);
534 TRACE("pointer at (%d,%d)\n", winX
, winY
);
539 /***********************************************************************
540 * InitMouse (X11DRV.@)
542 void X11DRV_InitMouse( BYTE
*key_state_table
)
544 pKeyStateTable
= key_state_table
;
548 /***********************************************************************
551 void X11DRV_ButtonPress( HWND hwnd
, XButtonEvent
*event
)
553 int buttonNum
= event
->button
- 1;
557 if (buttonNum
>= NB_BUTTONS
) return;
560 update_cursor( hwnd
, event
->window
);
561 get_coords( &hwnd
, event
->window
, event
->x
, event
->y
, &pt
);
569 wData
= -WHEEL_DELTA
;
572 update_key_state( event
->state
);
573 send_mouse_event( hwnd
, button_down_flags
[buttonNum
] | MOUSEEVENTF_ABSOLUTE
,
574 pt
.x
, pt
.y
, wData
, event
->time
);
578 /***********************************************************************
579 * X11DRV_ButtonRelease
581 void X11DRV_ButtonRelease( HWND hwnd
, XButtonEvent
*event
)
583 int buttonNum
= event
->button
- 1;
586 if (buttonNum
>= NB_BUTTONS
|| !button_up_flags
[buttonNum
]) return;
589 update_cursor( hwnd
, event
->window
);
590 get_coords( &hwnd
, event
->window
, event
->x
, event
->y
, &pt
);
591 update_key_state( event
->state
);
592 send_mouse_event( hwnd
, button_up_flags
[buttonNum
] | MOUSEEVENTF_ABSOLUTE
,
593 pt
.x
, pt
.y
, 0, event
->time
);
597 /***********************************************************************
598 * X11DRV_MotionNotify
600 void X11DRV_MotionNotify( HWND hwnd
, XMotionEvent
*event
)
606 update_cursor( hwnd
, event
->window
);
607 get_coords( &hwnd
, event
->window
, event
->x
, event
->y
, &pt
);
608 update_key_state( event
->state
);
609 send_mouse_event( hwnd
, MOUSEEVENTF_MOVE
| MOUSEEVENTF_ABSOLUTE
,
610 pt
.x
, pt
.y
, 0, event
->time
);
614 /***********************************************************************
617 void X11DRV_EnterNotify( HWND hwnd
, XCrossingEvent
*event
)
621 if (event
->detail
== NotifyVirtual
|| event
->detail
== NotifyNonlinearVirtual
) return;
624 /* simulate a mouse motion event */
625 update_cursor( hwnd
, event
->window
);
626 get_coords( &hwnd
, event
->window
, event
->x
, event
->y
, &pt
);
627 update_key_state( event
->state
);
628 send_mouse_event( hwnd
, MOUSEEVENTF_MOVE
| MOUSEEVENTF_ABSOLUTE
,
629 pt
.x
, pt
.y
, 0, event
->time
);
633 #ifdef HAVE_LIBXXF86DGA2
634 /**********************************************************************
635 * X11DRV_DGAMotionEvent
637 void X11DRV_DGAMotionEvent( HWND hwnd
, XDGAMotionEvent
*event
)
639 update_key_state( event
->state
);
640 send_mouse_event( hwnd
, MOUSEEVENTF_MOVE
, event
->dx
, event
->dy
, 0, event
->time
);
643 /**********************************************************************
644 * X11DRV_DGAButtonPressEvent
646 void X11DRV_DGAButtonPressEvent( HWND hwnd
, XDGAButtonEvent
*event
)
648 int buttonNum
= event
->button
- 1;
650 if (buttonNum
>= NB_BUTTONS
) return;
651 update_key_state( event
->state
);
652 send_mouse_event( hwnd
, button_down_flags
[buttonNum
], 0, 0, 0, event
->time
);
655 /**********************************************************************
656 * X11DRV_DGAButtonReleaseEvent
658 void X11DRV_DGAButtonReleaseEvent( HWND hwnd
, XDGAButtonEvent
*event
)
660 int buttonNum
= event
->button
- 1;
662 if (buttonNum
>= NB_BUTTONS
) return;
663 update_key_state( event
->state
);
664 send_mouse_event( hwnd
, button_up_flags
[buttonNum
], 0, 0, 0, event
->time
);
666 #endif /* HAVE_LIBXXF86DGA2 */