push decde5eed3d79f9d889b4d757f73e86ce6ff9241
[wine/hacks.git] / dlls / winex11.drv / mouse.c
blobd939bb08fe86044f2a90644d1c935292dbe659ef
1 /*
2 * X11 mouse driver
4 * Copyright 1998 Ulrich Weigand
5 * Copyright 2007 Henri Verbeet
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "config.h"
23 #include "wine/port.h"
25 #include <X11/Xlib.h>
26 #include <stdarg.h>
28 #ifdef SONAME_LIBXCURSOR
29 # include <X11/Xcursor/Xcursor.h>
30 static void *xcursor_handle;
31 # define MAKE_FUNCPTR(f) static typeof(f) * p##f
32 MAKE_FUNCPTR(XcursorImageCreate);
33 MAKE_FUNCPTR(XcursorImageDestroy);
34 MAKE_FUNCPTR(XcursorImageLoadCursor);
35 # undef MAKE_FUNCPTR
36 #endif /* SONAME_LIBXCURSOR */
38 #define NONAMELESSUNION
39 #define NONAMELESSSTRUCT
40 #include "windef.h"
41 #include "winbase.h"
42 #include "wine/winuser16.h"
44 #include "x11drv.h"
45 #include "wine/server.h"
46 #include "wine/library.h"
47 #include "wine/debug.h"
49 WINE_DEFAULT_DEBUG_CHANNEL(cursor);
51 /**********************************************************************/
53 #ifndef Button6Mask
54 #define Button6Mask (1<<13)
55 #endif
56 #ifndef Button7Mask
57 #define Button7Mask (1<<14)
58 #endif
60 #define NB_BUTTONS 9 /* Windows can handle 5 buttons and the wheel too */
62 static const UINT button_down_flags[NB_BUTTONS] =
64 MOUSEEVENTF_LEFTDOWN,
65 MOUSEEVENTF_MIDDLEDOWN,
66 MOUSEEVENTF_RIGHTDOWN,
67 MOUSEEVENTF_WHEEL,
68 MOUSEEVENTF_WHEEL,
69 MOUSEEVENTF_XDOWN, /* FIXME: horizontal wheel */
70 MOUSEEVENTF_XDOWN,
71 MOUSEEVENTF_XDOWN,
72 MOUSEEVENTF_XDOWN
75 static const UINT button_up_flags[NB_BUTTONS] =
77 MOUSEEVENTF_LEFTUP,
78 MOUSEEVENTF_MIDDLEUP,
79 MOUSEEVENTF_RIGHTUP,
82 MOUSEEVENTF_XUP,
83 MOUSEEVENTF_XUP,
84 MOUSEEVENTF_XUP,
85 MOUSEEVENTF_XUP
88 POINT cursor_pos;
89 static DWORD last_time_modified;
90 static RECT cursor_clip; /* Cursor clipping rect */
92 BOOL X11DRV_SetCursorPos( INT x, INT y );
95 /***********************************************************************
96 * X11DRV_Xcursor_Init
98 * Load the Xcursor library for use.
100 void X11DRV_Xcursor_Init(void)
102 #ifdef SONAME_LIBXCURSOR
103 xcursor_handle = wine_dlopen(SONAME_LIBXCURSOR, RTLD_NOW, NULL, 0);
104 if (!xcursor_handle) /* wine_dlopen failed. */
106 WARN("Xcursor failed to load. Using fallback code.\n");
107 return;
109 #define LOAD_FUNCPTR(f) \
110 p##f = wine_dlsym(xcursor_handle, #f, NULL, 0)
112 LOAD_FUNCPTR(XcursorImageCreate);
113 LOAD_FUNCPTR(XcursorImageDestroy);
114 LOAD_FUNCPTR(XcursorImageLoadCursor);
115 #undef LOAD_FUNCPTR
116 #endif /* SONAME_LIBXCURSOR */
120 /***********************************************************************
121 * get_coords
123 * get the coordinates of a mouse event
125 static inline void get_coords( HWND hwnd, Window window, int x, int y, POINT *pt )
127 struct x11drv_win_data *data = X11DRV_get_win_data( hwnd );
129 if (!data) return;
131 if (window == data->client_window)
133 pt->x = x + data->client_rect.left;
134 pt->y = y + data->client_rect.top;
136 else
138 pt->x = x + data->whole_rect.left;
139 pt->y = y + data->whole_rect.top;
143 /***********************************************************************
144 * clip_point_to_rect
146 * Clip point to the provided rectangle
148 static inline void clip_point_to_rect( LPCRECT rect, LPPOINT pt )
150 if (pt->x < rect->left) pt->x = rect->left;
151 else if (pt->x >= rect->right) pt->x = rect->right - 1;
152 if (pt->y < rect->top) pt->y = rect->top;
153 else if (pt->y >= rect->bottom) pt->y = rect->bottom - 1;
156 /***********************************************************************
157 * update_button_state
159 * Update the button state with what X provides us
161 static inline void update_button_state( unsigned int state )
163 key_state_table[VK_LBUTTON] = (state & Button1Mask ? 0x80 : 0);
164 key_state_table[VK_MBUTTON] = (state & Button2Mask ? 0x80 : 0);
165 key_state_table[VK_RBUTTON] = (state & Button3Mask ? 0x80 : 0);
166 /* X-buttons are not reported from XQueryPointer */
170 /***********************************************************************
171 * update_mouse_state
173 * Update the various window states on a mouse event.
175 static void update_mouse_state( HWND hwnd, Window window, int x, int y, unsigned int state, POINT *pt )
177 struct x11drv_thread_data *data = x11drv_thread_data();
179 get_coords( hwnd, window, x, y, pt );
181 /* update the cursor */
183 if (data->cursor_window != window)
185 data->cursor_window = window;
186 wine_tsx11_lock();
187 if (data->cursor) XDefineCursor( data->display, window, data->cursor );
188 wine_tsx11_unlock();
191 /* update the wine server Z-order */
193 if (window != data->grab_window &&
194 /* ignore event if a button is pressed, since the mouse is then grabbed too */
195 !(state & (Button1Mask|Button2Mask|Button3Mask|Button4Mask|Button5Mask|Button6Mask|Button7Mask)))
197 SERVER_START_REQ( update_window_zorder )
199 req->window = hwnd;
200 req->rect.left = pt->x;
201 req->rect.top = pt->y;
202 req->rect.right = pt->x + 1;
203 req->rect.bottom = pt->y + 1;
204 wine_server_call( req );
206 SERVER_END_REQ;
211 /***********************************************************************
212 * get_key_state
214 static WORD get_key_state(void)
216 WORD ret = 0;
218 if (GetSystemMetrics( SM_SWAPBUTTON ))
220 if (key_state_table[VK_RBUTTON] & 0x80) ret |= MK_LBUTTON;
221 if (key_state_table[VK_LBUTTON] & 0x80) ret |= MK_RBUTTON;
223 else
225 if (key_state_table[VK_LBUTTON] & 0x80) ret |= MK_LBUTTON;
226 if (key_state_table[VK_RBUTTON] & 0x80) ret |= MK_RBUTTON;
228 if (key_state_table[VK_MBUTTON] & 0x80) ret |= MK_MBUTTON;
229 if (key_state_table[VK_SHIFT] & 0x80) ret |= MK_SHIFT;
230 if (key_state_table[VK_CONTROL] & 0x80) ret |= MK_CONTROL;
231 if (key_state_table[VK_XBUTTON1] & 0x80) ret |= MK_XBUTTON1;
232 if (key_state_table[VK_XBUTTON2] & 0x80) ret |= MK_XBUTTON2;
233 return ret;
237 /***********************************************************************
238 * queue_raw_mouse_message
240 static void queue_raw_mouse_message( UINT message, HWND hwnd, DWORD x, DWORD y,
241 DWORD data, DWORD time, DWORD extra_info, UINT injected_flags )
243 MSLLHOOKSTRUCT hook;
245 hook.pt.x = x;
246 hook.pt.y = y;
247 hook.mouseData = MAKELONG( 0, data );
248 hook.flags = injected_flags;
249 hook.time = time;
250 hook.dwExtraInfo = extra_info;
252 last_time_modified = GetTickCount();
253 if (HOOK_CallHooks( WH_MOUSE_LL, HC_ACTION, message, (LPARAM)&hook, TRUE )) return;
255 SERVER_START_REQ( send_hardware_message )
257 req->id = (injected_flags & LLMHF_INJECTED) ? 0 : GetCurrentThreadId();
258 req->win = hwnd;
259 req->msg = message;
260 req->wparam = MAKEWPARAM( get_key_state(), data );
261 req->lparam = 0;
262 req->x = x;
263 req->y = y;
264 req->time = time;
265 req->info = extra_info;
266 wine_server_call( req );
268 SERVER_END_REQ;
273 /***********************************************************************
274 * X11DRV_send_mouse_input
276 void X11DRV_send_mouse_input( HWND hwnd, DWORD flags, DWORD x, DWORD y,
277 DWORD data, DWORD time, DWORD extra_info, UINT injected_flags )
279 POINT pt;
281 if (flags & MOUSEEVENTF_MOVE && flags & MOUSEEVENTF_ABSOLUTE)
283 if (injected_flags & LLMHF_INJECTED)
285 pt.x = (x * screen_width) >> 16;
286 pt.y = (y * screen_height) >> 16;
288 else
290 pt.x = x;
291 pt.y = y;
292 wine_tsx11_lock();
293 if (cursor_pos.x == x && cursor_pos.y == y &&
294 (flags & ~(MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE)))
295 flags &= ~MOUSEEVENTF_MOVE;
296 wine_tsx11_unlock();
299 else if (flags & MOUSEEVENTF_MOVE)
301 int accel[3], xMult = 1, yMult = 1;
303 /* dx and dy can be negative numbers for relative movements */
304 SystemParametersInfoW(SPI_GETMOUSE, 0, accel, 0);
306 if (abs(x) > accel[0] && accel[2] != 0)
308 xMult = 2;
309 if ((abs(x) > accel[1]) && (accel[2] == 2)) xMult = 4;
311 if (abs(y) > accel[0] && accel[2] != 0)
313 yMult = 2;
314 if ((abs(y) > accel[1]) && (accel[2] == 2)) yMult = 4;
317 wine_tsx11_lock();
318 pt.x = cursor_pos.x + (long)x * xMult;
319 pt.y = cursor_pos.y + (long)y * yMult;
320 wine_tsx11_unlock();
322 else
324 wine_tsx11_lock();
325 pt = cursor_pos;
326 wine_tsx11_unlock();
329 if (flags & MOUSEEVENTF_MOVE)
331 queue_raw_mouse_message( WM_MOUSEMOVE, hwnd, pt.x, pt.y, data, time,
332 extra_info, injected_flags );
333 if ((injected_flags & LLMHF_INJECTED) &&
334 ((flags & MOUSEEVENTF_ABSOLUTE) || x || y)) /* we have to actually move the cursor */
336 X11DRV_SetCursorPos( pt.x, pt.y );
338 else
340 wine_tsx11_lock();
341 clip_point_to_rect( &cursor_clip, &pt);
342 cursor_pos = pt;
343 wine_tsx11_unlock();
346 if (flags & MOUSEEVENTF_LEFTDOWN)
348 key_state_table[VK_LBUTTON] |= 0xc0;
349 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONDOWN : WM_LBUTTONDOWN,
350 hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
352 if (flags & MOUSEEVENTF_LEFTUP)
354 key_state_table[VK_LBUTTON] &= ~0x80;
355 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONUP : WM_LBUTTONUP,
356 hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
358 if (flags & MOUSEEVENTF_RIGHTDOWN)
360 key_state_table[VK_RBUTTON] |= 0xc0;
361 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONDOWN : WM_RBUTTONDOWN,
362 hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
364 if (flags & MOUSEEVENTF_RIGHTUP)
366 key_state_table[VK_RBUTTON] &= ~0x80;
367 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONUP : WM_RBUTTONUP,
368 hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
370 if (flags & MOUSEEVENTF_MIDDLEDOWN)
372 key_state_table[VK_MBUTTON] |= 0xc0;
373 queue_raw_mouse_message( WM_MBUTTONDOWN, hwnd, pt.x, pt.y, data, time,
374 extra_info, injected_flags );
376 if (flags & MOUSEEVENTF_MIDDLEUP)
378 key_state_table[VK_MBUTTON] &= ~0x80;
379 queue_raw_mouse_message( WM_MBUTTONUP, hwnd, pt.x, pt.y, data, time,
380 extra_info, injected_flags );
382 if (flags & MOUSEEVENTF_WHEEL)
384 queue_raw_mouse_message( WM_MOUSEWHEEL, hwnd, pt.x, pt.y, data, time,
385 extra_info, injected_flags );
387 if (flags & MOUSEEVENTF_XDOWN)
389 key_state_table[VK_XBUTTON1 + data - 1] |= 0xc0;
390 queue_raw_mouse_message( WM_XBUTTONDOWN, hwnd, pt.x, pt.y, data, time,
391 extra_info, injected_flags );
393 if (flags & MOUSEEVENTF_XUP)
395 key_state_table[VK_XBUTTON1 + data - 1] &= ~0x80;
396 queue_raw_mouse_message( WM_XBUTTONUP, hwnd, pt.x, pt.y, data, time,
397 extra_info, injected_flags );
402 #ifdef SONAME_LIBXCURSOR
404 /***********************************************************************
405 * create_cursor_image
407 * Create an XcursorImage from a CURSORICONINFO
409 static XcursorImage *create_cursor_image( CURSORICONINFO *ptr )
411 int x, xmax;
412 int y, ymax;
413 int and_size;
414 unsigned char *and_bits, *and_ptr, *xor_bits, *xor_ptr;
415 int and_width_bytes, xor_width_bytes;
416 XcursorPixel *pixel_ptr;
417 XcursorImage *image;
418 BOOL alpha_zero = TRUE;
420 ymax = (ptr->nHeight > 32) ? 32 : ptr->nHeight;
421 xmax = (ptr->nWidth > 32) ? 32 : ptr->nWidth;
423 and_width_bytes = xmax / 8;
424 xor_width_bytes = and_width_bytes * ptr->bBitsPerPixel;
426 and_size = ptr->nWidth * ptr->nHeight / 8;
427 and_ptr = and_bits = (unsigned char *)(ptr + 1);
429 xor_ptr = xor_bits = and_ptr + and_size;
431 image = pXcursorImageCreate( xmax, ymax );
432 pixel_ptr = image->pixels;
434 /* Generally 32 bit bitmaps have an alpha channel which is used in favor
435 * of the AND mask. However, if all pixels have alpha = 0x00, the bitmap
436 * is treated like one without alpha and the masks are used. As soon as
437 * one pixel has alpha != 0x00, and the mask ignored as described in the
438 * docs.
440 * This is most likely for applications which create the bitmaps with
441 * CreateDIBitmap, which creates a device dependent bitmap, so the format
442 * that arrives when loading depends on the screen's bpp. Apps that were
443 * written at 8 / 16 bpp times do not know about the 32 bit alpha, so
444 * they would get a completely transparent cursor on 32 bit displays.
446 * Non-32 bit bitmaps always use the AND mask
448 if(ptr->bBitsPerPixel == 32)
450 for (y = 0; alpha_zero && y < ymax; ++y)
452 xor_ptr = xor_bits + (y * xor_width_bytes);
453 for (x = 0; x < xmax; ++x)
455 if (xor_ptr[3] != 0x00)
457 alpha_zero = FALSE;
458 break;
460 xor_ptr+=4;
465 /* On windows, to calculate the color for a pixel, first an AND is done
466 * with the background and the "and" bitmap, then an XOR with the "xor"
467 * bitmap. This means that when the data in the "and" bitmap is 0, the
468 * pixel will get the color as specified in the "xor" bitmap.
469 * However, if the data in the "and" bitmap is 1, the result will be the
470 * background XOR'ed with the value in the "xor" bitmap. In case the "xor"
471 * data is completely black (0x000000) the pixel will become transparent,
472 * in case it's white (0xffffff) the pixel will become the inverse of the
473 * background color.
475 * Since we can't support inverting colors, we map the grayscale value of
476 * the "xor" data to the alpha channel, and xor the color with either
477 * black or white.
479 for (y = 0; y < ymax; ++y)
481 and_ptr = and_bits + (y * and_width_bytes);
482 xor_ptr = xor_bits + (y * xor_width_bytes);
484 for (x = 0; x < xmax; ++x)
486 /* Xcursor pixel data is in ARGB format, with A in the high byte */
487 switch (ptr->bBitsPerPixel)
489 case 32:
490 /* BGRA, 8 bits each */
491 *pixel_ptr = *xor_ptr++;
492 *pixel_ptr |= *xor_ptr++ << 8;
493 *pixel_ptr |= *xor_ptr++ << 16;
494 *pixel_ptr |= *xor_ptr++ << 24;
495 break;
497 case 24:
498 /* BGR, 8 bits each */
499 *pixel_ptr = *xor_ptr++;
500 *pixel_ptr |= *xor_ptr++ << 8;
501 *pixel_ptr |= *xor_ptr++ << 16;
502 break;
504 case 16:
505 /* BGR, 5 red, 6 green, 5 blue */
506 *pixel_ptr = *xor_ptr * 0x1f;
507 *pixel_ptr |= (*xor_ptr & 0xe0) << 3;
508 ++xor_ptr;
509 *pixel_ptr |= (*xor_ptr & 0x07) << 11;
510 *pixel_ptr |= (*xor_ptr & 0xf8) << 13;
511 break;
513 case 1:
514 if (*xor_ptr & (1 << (7 - (x & 7)))) *pixel_ptr = 0xffffff;
515 else *pixel_ptr = 0;
516 if ((x & 7) == 7) ++xor_ptr;
517 break;
519 default:
520 FIXME("Currently no support for cursors with %d bits per pixel\n", ptr->bBitsPerPixel);
521 return 0;
524 if (alpha_zero)
526 /* Alpha channel */
527 if (~*and_ptr & (1 << (7 - (x & 7)))) *pixel_ptr |= 0xff << 24;
528 else if (*pixel_ptr)
530 int alpha = (*pixel_ptr & 0xff) * 0.30f
531 + ((*pixel_ptr & 0xff00) >> 8) * 0.55f
532 + ((*pixel_ptr & 0xff0000) >> 16) * 0.15f;
533 *pixel_ptr ^= ((x + y) % 2) ? 0xffffff : 0x000000;
534 *pixel_ptr |= alpha << 24;
536 if ((x & 7) == 7) ++and_ptr;
538 ++pixel_ptr;
542 return image;
546 /***********************************************************************
547 * create_xcursor_cursor
549 * Use Xcursor to create an X cursor from a Windows one.
551 static Cursor create_xcursor_cursor( Display *display, CURSORICONINFO *ptr )
553 Cursor cursor;
554 XcursorImage *image;
556 if (!ptr) /* Create an empty cursor */
558 image = pXcursorImageCreate( 1, 1 );
559 image->xhot = 0;
560 image->yhot = 0;
561 *(image->pixels) = 0;
562 cursor = pXcursorImageLoadCursor( display, image );
563 pXcursorImageDestroy( image );
565 return cursor;
568 image = create_cursor_image( ptr );
569 if (!image) return 0;
571 /* Make sure hotspot is valid */
572 image->xhot = ptr->ptHotSpot.x;
573 image->yhot = ptr->ptHotSpot.y;
574 if (image->xhot >= image->width ||
575 image->yhot >= image->height)
577 image->xhot = image->width / 2;
578 image->yhot = image->height / 2;
581 image->delay = 0;
583 cursor = pXcursorImageLoadCursor( display, image );
584 pXcursorImageDestroy( image );
586 return cursor;
589 #endif /* SONAME_LIBXCURSOR */
592 /***********************************************************************
593 * create_cursor
595 * Create an X cursor from a Windows one.
597 static Cursor create_cursor( Display *display, CURSORICONINFO *ptr )
599 Pixmap pixmapBits, pixmapMask, pixmapMaskInv = 0, pixmapAll;
600 XColor fg, bg;
601 Cursor cursor = None;
602 POINT hotspot;
603 char *bitMask32 = NULL;
605 #ifdef SONAME_LIBXCURSOR
606 if (pXcursorImageLoadCursor) return create_xcursor_cursor( display, ptr );
607 #endif
609 if (!ptr) /* Create an empty cursor */
611 static const char data[] = { 0 };
613 bg.red = bg.green = bg.blue = 0x0000;
614 pixmapBits = XCreateBitmapFromData( display, root_window, data, 1, 1 );
615 if (pixmapBits)
617 cursor = XCreatePixmapCursor( display, pixmapBits, pixmapBits,
618 &bg, &bg, 0, 0 );
619 XFreePixmap( display, pixmapBits );
622 else /* Create the X cursor from the bits */
624 XImage *image;
625 GC gc;
627 TRACE("Bitmap %dx%d planes=%d bpp=%d bytesperline=%d\n",
628 ptr->nWidth, ptr->nHeight, ptr->bPlanes, ptr->bBitsPerPixel,
629 ptr->nWidthBytes);
631 /* Create a pixmap and transfer all the bits to it */
633 /* NOTE: Following hack works, but only because XFree depth
634 * 1 images really use 1 bit/pixel (and so the same layout
635 * as the Windows cursor data). Perhaps use a more generic
636 * algorithm here.
638 /* This pixmap will be written with two bitmaps. The first is
639 * the mask and the second is the image.
641 if (!(pixmapAll = XCreatePixmap( display, root_window,
642 ptr->nWidth, ptr->nHeight * 2, 1 )))
643 return 0;
644 if (!(image = XCreateImage( display, visual,
645 1, ZPixmap, 0, (char *)(ptr + 1), ptr->nWidth,
646 ptr->nHeight * 2, 16, ptr->nWidthBytes/ptr->bBitsPerPixel)))
648 XFreePixmap( display, pixmapAll );
649 return 0;
651 gc = XCreateGC( display, pixmapAll, 0, NULL );
652 XSetGraphicsExposures( display, gc, False );
653 image->byte_order = MSBFirst;
654 image->bitmap_bit_order = MSBFirst;
655 image->bitmap_unit = 16;
656 _XInitImageFuncPtrs(image);
657 if (ptr->bPlanes * ptr->bBitsPerPixel == 1)
659 /* A plain old white on black cursor. */
660 fg.red = fg.green = fg.blue = 0xffff;
661 bg.red = bg.green = bg.blue = 0x0000;
662 XPutImage( display, pixmapAll, gc, image,
663 0, 0, 0, 0, ptr->nWidth, ptr->nHeight * 2 );
665 else
667 int rbits, gbits, bbits, red, green, blue;
668 int rfg, gfg, bfg, rbg, gbg, bbg;
669 int rscale, gscale, bscale;
670 int x, y, xmax, ymax, byteIndex, xorIndex;
671 unsigned char *theMask, *theImage, theChar;
672 int threshold, fgBits, bgBits, bitShifted;
673 BYTE pXorBits[128]; /* Up to 32x32 icons */
675 switch (ptr->bBitsPerPixel)
677 case 32:
678 bitMask32 = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
679 ptr->nWidth * ptr->nHeight / 8 );
680 /* Fallthrough */
681 case 24:
682 rbits = 8;
683 gbits = 8;
684 bbits = 8;
685 threshold = 0x40;
686 break;
687 case 16:
688 rbits = 5;
689 gbits = 6;
690 bbits = 5;
691 threshold = 0x40;
692 break;
693 default:
694 FIXME("Currently no support for cursors with %d bits per pixel\n",
695 ptr->bBitsPerPixel);
696 XFreePixmap( display, pixmapAll );
697 XFreeGC( display, gc );
698 image->data = NULL;
699 XDestroyImage( image );
700 return 0;
702 /* The location of the mask. */
703 theMask = (unsigned char *)(ptr + 1);
704 /* The mask should still be 1 bit per pixel. The color image
705 * should immediately follow the mask.
707 theImage = &theMask[ptr->nWidth/8 * ptr->nHeight];
708 rfg = gfg = bfg = rbg = gbg = bbg = 0;
709 byteIndex = 0;
710 xorIndex = 0;
711 fgBits = 0;
712 bitShifted = 0x01;
713 xmax = (ptr->nWidth > 32) ? 32 : ptr->nWidth;
714 if (ptr->nWidth > 32) {
715 ERR("Got a %dx%d cursor. Cannot handle larger than 32x32.\n",
716 ptr->nWidth, ptr->nHeight);
718 ymax = (ptr->nHeight > 32) ? 32 : ptr->nHeight;
720 memset(pXorBits, 0, 128);
721 for (y=0; y<ymax; y++)
723 for (x=0; x<xmax; x++)
725 red = green = blue = 0;
726 switch (ptr->bBitsPerPixel)
728 case 32:
729 theChar = theImage[byteIndex++];
730 blue = theChar;
731 theChar = theImage[byteIndex++];
732 green = theChar;
733 theChar = theImage[byteIndex++];
734 red = theChar;
735 theChar = theImage[byteIndex++];
736 /* If the alpha channel is >5% transparent,
737 * assume that we can add it to the bitMask32.
739 if (theChar > 0x0D)
740 *(bitMask32 + (y*xmax+x)/8) |= 1 << (x & 7);
741 break;
742 case 24:
743 theChar = theImage[byteIndex++];
744 blue = theChar;
745 theChar = theImage[byteIndex++];
746 green = theChar;
747 theChar = theImage[byteIndex++];
748 red = theChar;
749 break;
750 case 16:
751 theChar = theImage[byteIndex++];
752 blue = theChar & 0x1F;
753 green = (theChar & 0xE0) >> 5;
754 theChar = theImage[byteIndex++];
755 green |= (theChar & 0x07) << 3;
756 red = (theChar & 0xF8) >> 3;
757 break;
760 if (red+green+blue > threshold)
762 rfg += red;
763 gfg += green;
764 bfg += blue;
765 fgBits++;
766 pXorBits[xorIndex] |= bitShifted;
768 else
770 rbg += red;
771 gbg += green;
772 bbg += blue;
774 if (x%8 == 7)
776 bitShifted = 0x01;
777 xorIndex++;
779 else
780 bitShifted = bitShifted << 1;
783 rscale = 1 << (16 - rbits);
784 gscale = 1 << (16 - gbits);
785 bscale = 1 << (16 - bbits);
786 if (fgBits)
788 fg.red = rfg * rscale / fgBits;
789 fg.green = gfg * gscale / fgBits;
790 fg.blue = bfg * bscale / fgBits;
792 else fg.red = fg.green = fg.blue = 0;
793 bgBits = xmax * ymax - fgBits;
794 if (bgBits)
796 bg.red = rbg * rscale / bgBits;
797 bg.green = gbg * gscale / bgBits;
798 bg.blue = bbg * bscale / bgBits;
800 else bg.red = bg.green = bg.blue = 0;
801 pixmapBits = XCreateBitmapFromData( display, root_window, (char *)pXorBits, xmax, ymax );
802 if (!pixmapBits)
804 HeapFree( GetProcessHeap(), 0, bitMask32 );
805 XFreePixmap( display, pixmapAll );
806 XFreeGC( display, gc );
807 image->data = NULL;
808 XDestroyImage( image );
809 return 0;
812 /* Put the mask. */
813 XPutImage( display, pixmapAll, gc, image,
814 0, 0, 0, 0, ptr->nWidth, ptr->nHeight );
815 XSetFunction( display, gc, GXcopy );
816 /* Put the image */
817 XCopyArea( display, pixmapBits, pixmapAll, gc,
818 0, 0, xmax, ymax, 0, ptr->nHeight );
819 XFreePixmap( display, pixmapBits );
821 image->data = NULL;
822 XDestroyImage( image );
824 /* Now create the 2 pixmaps for bits and mask */
826 pixmapBits = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 );
827 if (ptr->bBitsPerPixel != 32)
829 pixmapMaskInv = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 );
830 pixmapMask = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 );
832 /* Make sure everything went OK so far */
833 if (pixmapBits && pixmapMask && pixmapMaskInv)
835 /* We have to do some magic here, as cursors are not fully
836 * compatible between Windows and X11. Under X11, there are
837 * only 3 possible color cursor: black, white and masked. So
838 * we map the 4th Windows color (invert the bits on the screen)
839 * to black and an additional white bit on an other place
840 * (+1,+1). This require some boolean arithmetic:
842 * Windows | X11
843 * And Xor Result | Bits Mask Result
844 * 0 0 black | 0 1 background
845 * 0 1 white | 1 1 foreground
846 * 1 0 no change | X 0 no change
847 * 1 1 inverted | 0 1 background
849 * which gives:
850 * Bits = not 'And' and 'Xor' or 'And2' and 'Xor2'
851 * Mask = not 'And' or 'Xor' or 'And2' and 'Xor2'
853 * FIXME: apparently some servers do support 'inverted' color.
854 * I don't know if it's correct per the X spec, but maybe we
855 * ought to take advantage of it. -- AJ
857 XSetFunction( display, gc, GXcopy );
858 XCopyArea( display, pixmapAll, pixmapBits, gc,
859 0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
860 XCopyArea( display, pixmapAll, pixmapMask, gc,
861 0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
862 XCopyArea( display, pixmapAll, pixmapMaskInv, gc,
863 0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
864 XSetFunction( display, gc, GXand );
865 XCopyArea( display, pixmapAll, pixmapMaskInv, gc,
866 0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
867 XSetFunction( display, gc, GXandReverse );
868 XCopyArea( display, pixmapAll, pixmapBits, gc,
869 0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
870 XSetFunction( display, gc, GXorReverse );
871 XCopyArea( display, pixmapAll, pixmapMask, gc,
872 0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
873 /* Additional white */
874 XSetFunction( display, gc, GXor );
875 XCopyArea( display, pixmapMaskInv, pixmapMask, gc,
876 0, 0, ptr->nWidth, ptr->nHeight, 1, 1 );
877 XCopyArea( display, pixmapMaskInv, pixmapBits, gc,
878 0, 0, ptr->nWidth, ptr->nHeight, 1, 1 );
879 XSetFunction( display, gc, GXcopy );
882 else
884 pixmapMask = XCreateBitmapFromData( display, root_window,
885 bitMask32, ptr->nWidth,
886 ptr->nHeight );
887 HeapFree( GetProcessHeap(), 0, bitMask32 );
890 /* Make sure hotspot is valid */
891 hotspot.x = ptr->ptHotSpot.x;
892 hotspot.y = ptr->ptHotSpot.y;
893 if (hotspot.x < 0 || hotspot.x >= ptr->nWidth ||
894 hotspot.y < 0 || hotspot.y >= ptr->nHeight)
896 hotspot.x = ptr->nWidth / 2;
897 hotspot.y = ptr->nHeight / 2;
900 if (pixmapBits && pixmapMask)
901 cursor = XCreatePixmapCursor( display, pixmapBits, pixmapMask,
902 &fg, &bg, hotspot.x, hotspot.y );
904 /* Now free everything */
906 if (pixmapAll) XFreePixmap( display, pixmapAll );
907 if (pixmapBits) XFreePixmap( display, pixmapBits );
908 if (pixmapMask) XFreePixmap( display, pixmapMask );
909 if (pixmapMaskInv) XFreePixmap( display, pixmapMaskInv );
910 XFreeGC( display, gc );
912 return cursor;
916 /***********************************************************************
917 * SetCursor (X11DRV.@)
919 void X11DRV_SetCursor( CURSORICONINFO *lpCursor )
921 struct x11drv_thread_data *data = x11drv_init_thread_data();
922 Cursor cursor;
924 if (lpCursor)
925 TRACE("%ux%u, planes %u, bpp %u\n",
926 lpCursor->nWidth, lpCursor->nHeight, lpCursor->bPlanes, lpCursor->bBitsPerPixel);
927 else
928 TRACE("NULL\n");
930 /* set the same cursor for all top-level windows of the current thread */
932 wine_tsx11_lock();
933 cursor = create_cursor( data->display, lpCursor );
934 if (cursor)
936 if (data->cursor) XFreeCursor( data->display, data->cursor );
937 data->cursor = cursor;
938 if (data->cursor_window)
940 XDefineCursor( data->display, data->cursor_window, cursor );
941 /* Make the change take effect immediately */
942 XFlush( data->display );
945 wine_tsx11_unlock();
948 /***********************************************************************
949 * SetCursorPos (X11DRV.@)
951 BOOL X11DRV_SetCursorPos( INT x, INT y )
953 Display *display = thread_init_display();
954 POINT pt;
956 TRACE( "warping to (%d,%d)\n", x, y );
958 wine_tsx11_lock();
959 if (cursor_pos.x == x && cursor_pos.y == y)
961 wine_tsx11_unlock();
962 /* We still need to generate WM_MOUSEMOVE */
963 queue_raw_mouse_message( WM_MOUSEMOVE, NULL, x, y, 0, GetCurrentTime(), 0, 0 );
964 return TRUE;
967 pt.x = x; pt.y = y;
968 clip_point_to_rect( &cursor_clip, &pt);
969 XWarpPointer( display, root_window, root_window, 0, 0, 0, 0,
970 pt.x - virtual_screen_rect.left, pt.y - virtual_screen_rect.top );
971 XFlush( display ); /* avoids bad mouse lag in games that do their own mouse warping */
972 cursor_pos = pt;
973 wine_tsx11_unlock();
974 return TRUE;
977 /***********************************************************************
978 * GetCursorPos (X11DRV.@)
980 BOOL X11DRV_GetCursorPos(LPPOINT pos)
982 Display *display = thread_init_display();
983 Window root, child;
984 int rootX, rootY, winX, winY;
985 unsigned int xstate;
987 wine_tsx11_lock();
988 if ((GetTickCount() - last_time_modified > 100) &&
989 XQueryPointer( display, root_window, &root, &child,
990 &rootX, &rootY, &winX, &winY, &xstate ))
992 update_button_state( xstate );
993 winX += virtual_screen_rect.left;
994 winY += virtual_screen_rect.top;
995 TRACE("pointer at (%d,%d)\n", winX, winY );
996 cursor_pos.x = winX;
997 cursor_pos.y = winY;
999 *pos = cursor_pos;
1000 wine_tsx11_unlock();
1001 return TRUE;
1005 /***********************************************************************
1006 * ClipCursor (X11DRV.@)
1008 * Set the cursor clipping rectangle.
1010 BOOL X11DRV_ClipCursor( LPCRECT clip )
1012 if (!IntersectRect( &cursor_clip, &virtual_screen_rect, clip ))
1013 cursor_clip = virtual_screen_rect;
1015 return TRUE;
1018 /***********************************************************************
1019 * X11DRV_ButtonPress
1021 void X11DRV_ButtonPress( HWND hwnd, XEvent *xev )
1023 XButtonEvent *event = &xev->xbutton;
1024 int buttonNum = event->button - 1;
1025 WORD wData = 0;
1026 POINT pt;
1028 if (buttonNum >= NB_BUTTONS) return;
1029 if (!hwnd) return;
1031 switch (buttonNum)
1033 case 3:
1034 wData = WHEEL_DELTA;
1035 break;
1036 case 4:
1037 wData = -WHEEL_DELTA;
1038 break;
1039 case 5:
1040 wData = XBUTTON1;
1041 break;
1042 case 6:
1043 wData = XBUTTON2;
1044 break;
1045 case 7:
1046 wData = XBUTTON1;
1047 break;
1048 case 8:
1049 wData = XBUTTON2;
1050 break;
1053 update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
1055 X11DRV_send_mouse_input( hwnd, button_down_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE,
1056 pt.x, pt.y, wData, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
1060 /***********************************************************************
1061 * X11DRV_ButtonRelease
1063 void X11DRV_ButtonRelease( HWND hwnd, XEvent *xev )
1065 XButtonEvent *event = &xev->xbutton;
1066 int buttonNum = event->button - 1;
1067 WORD wData = 0;
1068 POINT pt;
1070 if (buttonNum >= NB_BUTTONS || !button_up_flags[buttonNum]) return;
1071 if (!hwnd) return;
1073 switch (buttonNum)
1075 case 5:
1076 wData = XBUTTON1;
1077 break;
1078 case 6:
1079 wData = XBUTTON2;
1080 break;
1081 case 7:
1082 wData = XBUTTON1;
1083 break;
1084 case 8:
1085 wData = XBUTTON2;
1086 break;
1089 update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
1091 X11DRV_send_mouse_input( hwnd, button_up_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE,
1092 pt.x, pt.y, wData, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
1096 /***********************************************************************
1097 * X11DRV_MotionNotify
1099 void X11DRV_MotionNotify( HWND hwnd, XEvent *xev )
1101 XMotionEvent *event = &xev->xmotion;
1102 POINT pt;
1104 TRACE("hwnd %p, event->is_hint %d\n", hwnd, event->is_hint);
1106 if (!hwnd) return;
1108 update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
1110 X11DRV_send_mouse_input( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
1111 pt.x, pt.y, 0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
1115 /***********************************************************************
1116 * X11DRV_EnterNotify
1118 void X11DRV_EnterNotify( HWND hwnd, XEvent *xev )
1120 XCrossingEvent *event = &xev->xcrossing;
1121 POINT pt;
1123 TRACE("hwnd %p, event->detail %d\n", hwnd, event->detail);
1125 if (!hwnd) return;
1126 if (event->detail == NotifyVirtual || event->detail == NotifyNonlinearVirtual) return;
1127 if (event->window == x11drv_thread_data()->grab_window) return;
1129 /* simulate a mouse motion event */
1130 update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
1132 X11DRV_send_mouse_input( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
1133 pt.x, pt.y, 0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );