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 "ts_xf86dga2.h"
29 #include "wine/winuser16.h"
32 #include "wine/debug.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(cursor
);
36 /**********************************************************************/
38 #define NB_BUTTONS 5 /* Windows can handle 3 buttons and the wheel too */
40 static const UINT button_down_flags
[NB_BUTTONS
] =
43 MOUSEEVENTF_MIDDLEDOWN
,
44 MOUSEEVENTF_RIGHTDOWN
,
49 static const UINT button_up_flags
[NB_BUTTONS
] =
58 static BYTE
*pKeyStateTable
;
61 /***********************************************************************
64 * get the coordinates of a mouse event
66 static void get_coords( HWND
*hwnd
, Window window
, int x
, int y
, POINT
*pt
)
68 struct x11drv_win_data
*data
;
71 if (!(win
= WIN_GetPtr( *hwnd
)) || win
== WND_OTHER_PROCESS
) return;
72 data
= win
->pDriverData
;
74 if (window
== data
->whole_window
)
76 x
-= data
->client_rect
.left
;
77 y
-= data
->client_rect
.top
;
79 WIN_ReleasePtr( win
);
83 if (*hwnd
!= GetDesktopWindow())
85 ClientToScreen( *hwnd
, pt
);
86 *hwnd
= GetAncestor( *hwnd
, GA_ROOT
);
91 /***********************************************************************
94 * Update the key state with what X provides us
96 static void update_key_state( unsigned int state
)
98 pKeyStateTable
[VK_LBUTTON
] = (state
& Button1Mask
? 0x80 : 0);
99 pKeyStateTable
[VK_MBUTTON
] = (state
& Button2Mask
? 0x80 : 0);
100 pKeyStateTable
[VK_RBUTTON
] = (state
& Button3Mask
? 0x80 : 0);
101 pKeyStateTable
[VK_SHIFT
] = (state
& ShiftMask
? 0x80 : 0);
102 pKeyStateTable
[VK_CONTROL
] = (state
& ControlMask
? 0x80 : 0);
106 /***********************************************************************
109 static void send_mouse_event( HWND hwnd
, DWORD flags
, DWORD posX
, DWORD posY
,
110 DWORD data
, Time time
)
114 TRACE("(%04lX,%ld,%ld)\n", flags
, posX
, posY
);
116 if (flags
& MOUSEEVENTF_ABSOLUTE
)
118 int width
= GetSystemMetrics( SM_CXSCREEN
);
119 int height
= GetSystemMetrics( SM_CYSCREEN
);
120 /* Relative mouse movements seem not to be scaled as absolute ones */
121 posX
= (((long)posX
<< 16) + width
-1) / width
;
122 posY
= (((long)posY
<< 16) + height
-1) / height
;
125 input
.type
= WINE_INTERNAL_INPUT_MOUSE
;
126 input
.u
.mi
.dx
= posX
;
127 input
.u
.mi
.dy
= posY
;
128 input
.u
.mi
.mouseData
= data
;
129 input
.u
.mi
.dwFlags
= flags
;
130 input
.u
.mi
.time
= time
- X11DRV_server_startticks
;
131 input
.u
.mi
.dwExtraInfo
= (ULONG_PTR
)hwnd
;
132 SendInput( 1, &input
, sizeof(input
) );
136 /***********************************************************************
139 Cursor
X11DRV_GetCursor( Display
*display
, CURSORICONINFO
*ptr
)
141 Pixmap pixmapBits
, pixmapMask
, pixmapMaskInv
, pixmapAll
;
143 Cursor cursor
= None
;
145 if (!ptr
) /* Create an empty cursor */
147 static const char data
[] = { 0 };
149 bg
.red
= bg
.green
= bg
.blue
= 0x0000;
150 pixmapBits
= XCreateBitmapFromData( display
, root_window
, data
, 1, 1 );
153 cursor
= XCreatePixmapCursor( display
, pixmapBits
, pixmapBits
,
155 XFreePixmap( display
, pixmapBits
);
158 else /* Create the X cursor from the bits */
163 TRACE("Bitmap %dx%d planes=%d bpp=%d bytesperline=%d\n",
164 ptr
->nWidth
, ptr
->nHeight
, ptr
->bPlanes
, ptr
->bBitsPerPixel
,
166 /* Create a pixmap and transfer all the bits to it */
168 /* NOTE: Following hack works, but only because XFree depth
169 * 1 images really use 1 bit/pixel (and so the same layout
170 * as the Windows cursor data). Perhaps use a more generic
173 /* This pixmap will be written with two bitmaps. The first is
174 * the mask and the second is the image.
176 if (!(pixmapAll
= XCreatePixmap( display
, root_window
,
177 ptr
->nWidth
, ptr
->nHeight
* 2, 1 )))
179 if (!(image
= XCreateImage( display
, visual
,
180 1, ZPixmap
, 0, (char *)(ptr
+ 1), ptr
->nWidth
,
181 ptr
->nHeight
* 2, 16, ptr
->nWidthBytes
/ptr
->bBitsPerPixel
)))
183 XFreePixmap( display
, pixmapAll
);
186 gc
= XCreateGC( display
, pixmapAll
, 0, NULL
);
187 XSetGraphicsExposures( display
, gc
, False
);
188 image
->byte_order
= MSBFirst
;
189 image
->bitmap_bit_order
= MSBFirst
;
190 image
->bitmap_unit
= 16;
191 _XInitImageFuncPtrs(image
);
192 if (ptr
->bPlanes
* ptr
->bBitsPerPixel
== 1)
194 /* A plain old white on black cursor. */
195 fg
.red
= fg
.green
= fg
.blue
= 0xffff;
196 bg
.red
= bg
.green
= bg
.blue
= 0x0000;
197 XPutImage( display
, pixmapAll
, gc
, image
,
198 0, 0, 0, 0, ptr
->nWidth
, ptr
->nHeight
* 2 );
202 int rbits
, gbits
, bbits
, red
, green
, blue
;
203 int rfg
, gfg
, bfg
, rbg
, gbg
, bbg
;
204 int rscale
, gscale
, bscale
;
205 int x
, y
, xmax
, ymax
, bitIndex
, byteIndex
, xorIndex
;
206 unsigned char *theMask
, *theImage
, theChar
;
207 int threshold
, fgBits
, bgBits
, bitShifted
;
208 BYTE pXorBits
[128]; /* Up to 32x32 icons */
210 switch (ptr
->bBitsPerPixel
)
225 FIXME("Currently no support for cursors with %d bits per pixel\n",
227 XFreePixmap( display
, pixmapAll
);
228 XFreeGC( display
, gc
);
230 XDestroyImage( image
);
233 /* The location of the mask. */
234 theMask
= (char *)(ptr
+ 1);
235 /* The mask should still be 1 bit per pixel. The color image
236 * should immediately follow the mask.
238 theImage
= &theMask
[ptr
->nWidth
/8 * ptr
->nHeight
];
239 rfg
= gfg
= bfg
= rbg
= gbg
= bbg
= 0;
245 xmax
= (ptr
->nWidth
> 32) ? 32 : ptr
->nWidth
;
246 if (ptr
->nWidth
> 32) {
247 ERR("Got a %dx%d cursor. Cannot handle larger than 32x32.\n",
248 ptr
->nWidth
, ptr
->nHeight
);
250 ymax
= (ptr
->nHeight
> 32) ? 32 : ptr
->nHeight
;
252 memset(pXorBits
, 0, 128);
253 for (y
=0; y
<ymax
; y
++)
255 for (x
=0; x
<xmax
; x
++)
257 red
= green
= blue
= 0;
258 switch (ptr
->bBitsPerPixel
)
261 theChar
= theImage
[byteIndex
++];
263 theChar
= theImage
[byteIndex
++];
265 theChar
= theImage
[byteIndex
++];
269 theChar
= theImage
[byteIndex
++];
270 blue
= theChar
& 0x1F;
271 green
= (theChar
& 0xE0) >> 5;
272 theChar
= theImage
[byteIndex
++];
273 green
|= (theChar
& 0x07) << 3;
274 red
= (theChar
& 0xF8) >> 3;
278 if (red
+green
+blue
> threshold
)
284 pXorBits
[xorIndex
] |= bitShifted
;
298 bitShifted
= bitShifted
<< 1;
301 rscale
= 1 << (16 - rbits
);
302 gscale
= 1 << (16 - gbits
);
303 bscale
= 1 << (16 - bbits
);
306 fg
.red
= rfg
* rscale
/ fgBits
;
307 fg
.green
= gfg
* gscale
/ fgBits
;
308 fg
.blue
= bfg
* bscale
/ fgBits
;
310 else fg
.red
= fg
.green
= fg
.blue
= 0;
311 bgBits
= xmax
* ymax
- fgBits
;
314 bg
.red
= rbg
* rscale
/ bgBits
;
315 bg
.green
= gbg
* gscale
/ bgBits
;
316 bg
.blue
= bbg
* bscale
/ bgBits
;
318 else bg
.red
= bg
.green
= bg
.blue
= 0;
319 pixmapBits
= XCreateBitmapFromData( display
, root_window
, pXorBits
, xmax
, ymax
);
322 XFreePixmap( display
, pixmapAll
);
323 XFreeGC( display
, gc
);
325 XDestroyImage( image
);
330 XPutImage( display
, pixmapAll
, gc
, image
,
331 0, 0, 0, 0, ptr
->nWidth
, ptr
->nHeight
);
332 XSetFunction( display
, gc
, GXcopy
);
334 XCopyArea( display
, pixmapBits
, pixmapAll
, gc
,
335 0, 0, xmax
, ymax
, 0, ptr
->nHeight
);
336 XFreePixmap( display
, pixmapBits
);
339 XDestroyImage( image
);
341 /* Now create the 2 pixmaps for bits and mask */
343 pixmapBits
= XCreatePixmap( display
, root_window
, ptr
->nWidth
, ptr
->nHeight
, 1 );
344 pixmapMask
= XCreatePixmap( display
, root_window
, ptr
->nWidth
, ptr
->nHeight
, 1 );
345 pixmapMaskInv
= XCreatePixmap( display
, root_window
, ptr
->nWidth
, ptr
->nHeight
, 1 );
347 /* Make sure everything went OK so far */
349 if (pixmapBits
&& pixmapMask
&& pixmapMaskInv
)
351 /* We have to do some magic here, as cursors are not fully
352 * compatible between Windows and X11. Under X11, there
353 * are only 3 possible color cursor: black, white and
354 * masked. So we map the 4th Windows color (invert the
355 * bits on the screen) to black and an additional white bit on
356 * an other place (+1,+1). This require some boolean arithmetic:
359 * And Xor Result | Bits Mask Result
360 * 0 0 black | 0 1 background
361 * 0 1 white | 1 1 foreground
362 * 1 0 no change | X 0 no change
363 * 1 1 inverted | 0 1 background
366 * Bits = not 'And' and 'Xor' or 'And2' and 'Xor2'
367 * Mask = not 'And' or 'Xor' or 'And2' and 'Xor2'
369 * FIXME: apparently some servers do support 'inverted' color.
370 * I don't know if it's correct per the X spec, but maybe
371 * we ought to take advantage of it. -- AJ
373 XSetFunction( display
, gc
, GXcopy
);
374 XCopyArea( display
, pixmapAll
, pixmapBits
, gc
,
375 0, 0, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
376 XCopyArea( display
, pixmapAll
, pixmapMask
, gc
,
377 0, 0, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
378 XCopyArea( display
, pixmapAll
, pixmapMaskInv
, gc
,
379 0, 0, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
380 XSetFunction( display
, gc
, GXand
);
381 XCopyArea( display
, pixmapAll
, pixmapMaskInv
, gc
,
382 0, ptr
->nHeight
, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
383 XSetFunction( display
, gc
, GXandReverse
);
384 XCopyArea( display
, pixmapAll
, pixmapBits
, gc
,
385 0, ptr
->nHeight
, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
386 XSetFunction( display
, gc
, GXorReverse
);
387 XCopyArea( display
, pixmapAll
, pixmapMask
, gc
,
388 0, ptr
->nHeight
, ptr
->nWidth
, ptr
->nHeight
, 0, 0 );
389 /* Additional white */
390 XSetFunction( display
, gc
, GXor
);
391 XCopyArea( display
, pixmapMaskInv
, pixmapMask
, gc
,
392 0, 0, ptr
->nWidth
, ptr
->nHeight
, 1, 1 );
393 XCopyArea( display
, pixmapMaskInv
, pixmapBits
, gc
,
394 0, 0, ptr
->nWidth
, ptr
->nHeight
, 1, 1 );
395 XSetFunction( display
, gc
, GXcopy
);
396 cursor
= XCreatePixmapCursor( display
, pixmapBits
, pixmapMask
,
397 &fg
, &bg
, ptr
->ptHotSpot
.x
, ptr
->ptHotSpot
.y
);
400 /* Now free everything */
402 if (pixmapAll
) XFreePixmap( display
, pixmapAll
);
403 if (pixmapBits
) XFreePixmap( display
, pixmapBits
);
404 if (pixmapMask
) XFreePixmap( display
, pixmapMask
);
405 if (pixmapMaskInv
) XFreePixmap( display
, pixmapMaskInv
);
406 XFreeGC( display
, gc
);
411 /* set the cursor of a window; helper for X11DRV_SetCursor */
412 static BOOL CALLBACK
set_win_cursor( HWND hwnd
, LPARAM cursor
)
414 Window win
= X11DRV_get_whole_window( hwnd
);
415 if (win
) TSXDefineCursor( thread_display(), win
, (Cursor
)cursor
);
419 /***********************************************************************
420 * SetCursor (X11DRV.@)
422 void X11DRV_SetCursor( CURSORICONINFO
*lpCursor
)
426 if (root_window
!= DefaultRootWindow(gdi_display
))
428 /* If in desktop mode, set the cursor on the desktop window */
431 cursor
= X11DRV_GetCursor( gdi_display
, lpCursor
);
434 XDefineCursor( gdi_display
, root_window
, cursor
);
435 XFreeCursor( gdi_display
, cursor
);
439 else /* set the same cursor for all top-level windows of the current thread */
441 Display
*display
= thread_display();
444 cursor
= X11DRV_GetCursor( display
, lpCursor
);
448 /* EnumThreadWindows( GetCurrentThreadId(), set_win_cursor, (LPARAM)cursor );*/
449 EnumWindows( set_win_cursor
, (LPARAM
)cursor
);
450 TSXFreeCursor( display
, cursor
);
455 /***********************************************************************
456 * SetCursorPos (X11DRV.@)
458 void X11DRV_SetCursorPos( INT x
, INT y
)
460 Display
*display
= thread_display();
462 TRACE( "warping to (%d,%d)\n", x
, y
);
465 XWarpPointer( display
, root_window
, root_window
, 0, 0, 0, 0, x
, y
);
466 XFlush( display
); /* just in case */
470 /***********************************************************************
471 * GetCursorPos (X11DRV.@)
473 void X11DRV_GetCursorPos(LPPOINT pos
)
475 Display
*display
= thread_display();
477 int rootX
, rootY
, winX
, winY
;
480 if (!TSXQueryPointer( display
, root_window
, &root
, &child
,
481 &rootX
, &rootY
, &winX
, &winY
, &xstate
))
484 TRACE("pointer at (%d,%d)\n", winX
, winY
);
489 /***********************************************************************
490 * InitMouse (X11DRV.@)
492 void X11DRV_InitMouse( BYTE
*key_state_table
)
495 int root_x
, root_y
, child_x
, child_y
;
496 unsigned int KeyState
;
498 pKeyStateTable
= key_state_table
;
499 /* Get the current mouse position and simulate an absolute mouse
500 movement to initialize the mouse global variables */
501 TSXQueryPointer( thread_display(), root_window
, &root
, &child
,
502 &root_x
, &root_y
, &child_x
, &child_y
, &KeyState
);
503 update_key_state( KeyState
);
504 send_mouse_event( 0, MOUSEEVENTF_MOVE
| MOUSEEVENTF_ABSOLUTE
,
505 root_x
, root_y
, 0, GetTickCount() + X11DRV_server_startticks
);
509 /***********************************************************************
512 void X11DRV_ButtonPress( HWND hwnd
, XButtonEvent
*event
)
514 int buttonNum
= event
->button
- 1;
518 if (buttonNum
>= NB_BUTTONS
) return;
520 get_coords( &hwnd
, event
->window
, event
->x
, event
->y
, &pt
);
528 wData
= -WHEEL_DELTA
;
531 update_key_state( event
->state
);
532 send_mouse_event( hwnd
, button_down_flags
[buttonNum
] | MOUSEEVENTF_ABSOLUTE
,
533 pt
.x
, pt
.y
, wData
, event
->time
);
537 /***********************************************************************
538 * X11DRV_ButtonRelease
540 void X11DRV_ButtonRelease( HWND hwnd
, XButtonEvent
*event
)
542 int buttonNum
= event
->button
- 1;
545 if (buttonNum
>= NB_BUTTONS
|| !button_up_flags
[buttonNum
]) return;
547 get_coords( &hwnd
, event
->window
, event
->x
, event
->y
, &pt
);
548 update_key_state( event
->state
);
549 send_mouse_event( hwnd
, button_up_flags
[buttonNum
] | MOUSEEVENTF_ABSOLUTE
,
550 pt
.x
, pt
.y
, 0, event
->time
);
554 /***********************************************************************
555 * X11DRV_MotionNotify
557 void X11DRV_MotionNotify( HWND hwnd
, XMotionEvent
*event
)
561 get_coords( &hwnd
, event
->window
, event
->x
, event
->y
, &pt
);
562 update_key_state( event
->state
);
563 send_mouse_event( hwnd
, MOUSEEVENTF_MOVE
| MOUSEEVENTF_ABSOLUTE
,
564 pt
.x
, pt
.y
, 0, event
->time
);
568 #ifdef HAVE_LIBXXF86DGA2
569 /**********************************************************************
570 * X11DRV_DGAMotionEvent
572 void X11DRV_DGAMotionEvent( HWND hwnd
, XDGAMotionEvent
*event
)
574 update_key_state( event
->state
);
575 send_mouse_event( hwnd
, MOUSEEVENTF_MOVE
, event
->dx
, event
->dy
, 0, event
->time
);
578 /**********************************************************************
579 * X11DRV_DGAButtonPressEvent
581 void X11DRV_DGAButtonPressEvent( HWND hwnd
, XDGAButtonEvent
*event
)
583 int buttonNum
= event
->button
- 1;
585 if (buttonNum
>= NB_BUTTONS
) return;
586 update_key_state( event
->state
);
587 send_mouse_event( hwnd
, button_down_flags
[buttonNum
], 0, 0, 0, event
->time
);
590 /**********************************************************************
591 * X11DRV_DGAButtonReleaseEvent
593 void X11DRV_DGAButtonReleaseEvent( HWND hwnd
, XDGAButtonEvent
*event
)
595 int buttonNum
= event
->button
- 1;
597 if (buttonNum
>= NB_BUTTONS
) return;
598 update_key_state( event
->state
);
599 send_mouse_event( hwnd
, button_up_flags
[buttonNum
], 0, 0, 0, event
->time
);
601 #endif /* HAVE_LIBXXF86DGA2 */