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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #define NONAMELESSUNION
27 #define NONAMELESSSTRUCT
30 #include "wine/winuser16.h"
34 #include "wine/server.h"
35 #include "wine/debug.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(cursor);
39 /**********************************************************************/
42 #define Button6Mask (1<<13)
45 #define Button7Mask (1<<14)
48 #define NB_BUTTONS 7 /* Windows can handle 5 buttons and the wheel too */
50 static const UINT button_down_flags[NB_BUTTONS] =
53 MOUSEEVENTF_MIDDLEDOWN,
54 MOUSEEVENTF_RIGHTDOWN,
61 static const UINT button_up_flags[NB_BUTTONS] =
74 /***********************************************************************
77 * get the coordinates of a mouse event
79 static inline void get_coords( HWND hwnd, int x, int y, POINT *pt )
81 struct x11drv_win_data *data = X11DRV_get_win_data( hwnd );
85 pt->x = x + data->whole_rect.left;
86 pt->y = y + data->whole_rect.top;
90 /***********************************************************************
93 * Update the button state with what X provides us
95 static inline void update_button_state( unsigned int state )
97 key_state_table[VK_LBUTTON] = (state & Button1Mask ? 0x80 : 0);
98 key_state_table[VK_MBUTTON] = (state & Button2Mask ? 0x80 : 0);
99 key_state_table[VK_RBUTTON] = (state & Button3Mask ? 0x80 : 0);
100 key_state_table[VK_XBUTTON1]= (state & Button6Mask ? 0x80 : 0);
101 key_state_table[VK_XBUTTON2]= (state & Button7Mask ? 0x80 : 0);
105 /***********************************************************************
108 * Update the key state with what X provides us
110 static inline void update_key_state( unsigned int state )
112 key_state_table[VK_SHIFT] = (state & ShiftMask ? 0x80 : 0);
113 key_state_table[VK_CONTROL] = (state & ControlMask ? 0x80 : 0);
117 /***********************************************************************
120 * Update the various window states on a mouse event.
122 static void update_mouse_state( HWND hwnd, Window window, int x, int y, unsigned int state, POINT *pt )
124 struct x11drv_thread_data *data = x11drv_thread_data();
126 get_coords( hwnd, x, y, pt );
127 update_key_state( state );
129 /* update the cursor */
131 if (data->cursor_window != window)
133 data->cursor_window = window;
135 if (data->cursor) XDefineCursor( data->display, window, data->cursor );
139 /* update the wine server Z-order */
141 if (window != data->grab_window &&
142 /* ignore event if a button is pressed, since the mouse is then grabbed too */
143 !(state & (Button1Mask|Button2Mask|Button3Mask|Button4Mask|Button5Mask|Button6Mask|Button7Mask)))
145 SERVER_START_REQ( update_window_zorder )
148 req->rect.left = pt->x;
149 req->rect.top = pt->y;
150 req->rect.right = pt->x + 1;
151 req->rect.bottom = pt->y + 1;
152 wine_server_call( req );
159 /***********************************************************************
162 static WORD get_key_state(void)
166 if (GetSystemMetrics( SM_SWAPBUTTON ))
168 if (key_state_table[VK_RBUTTON] & 0x80) ret |= MK_LBUTTON;
169 if (key_state_table[VK_LBUTTON] & 0x80) ret |= MK_RBUTTON;
173 if (key_state_table[VK_LBUTTON] & 0x80) ret |= MK_LBUTTON;
174 if (key_state_table[VK_RBUTTON] & 0x80) ret |= MK_RBUTTON;
176 if (key_state_table[VK_MBUTTON] & 0x80) ret |= MK_MBUTTON;
177 if (key_state_table[VK_SHIFT] & 0x80) ret |= MK_SHIFT;
178 if (key_state_table[VK_CONTROL] & 0x80) ret |= MK_CONTROL;
179 if (key_state_table[VK_XBUTTON1] & 0x80) ret |= MK_XBUTTON1;
180 if (key_state_table[VK_XBUTTON2] & 0x80) ret |= MK_XBUTTON2;
185 /***********************************************************************
186 * queue_raw_mouse_message
188 static void queue_raw_mouse_message( UINT message, HWND hwnd, DWORD x, DWORD y,
189 DWORD data, DWORD time, DWORD extra_info, UINT injected_flags )
195 hook.mouseData = MAKELONG( 0, data );
196 hook.flags = injected_flags;
198 hook.dwExtraInfo = extra_info;
200 if (HOOK_CallHooks( WH_MOUSE_LL, HC_ACTION, message, (LPARAM)&hook, TRUE )) return;
202 SERVER_START_REQ( send_hardware_message )
204 req->id = (injected_flags & LLMHF_INJECTED) ? 0 : GetCurrentThreadId();
207 req->wparam = MAKEWPARAM( get_key_state(), data );
212 req->info = extra_info;
213 wine_server_call( req );
220 /***********************************************************************
221 * X11DRV_send_mouse_input
223 void X11DRV_send_mouse_input( HWND hwnd, DWORD flags, DWORD x, DWORD y,
224 DWORD data, DWORD time, DWORD extra_info, UINT injected_flags )
228 if (flags & MOUSEEVENTF_ABSOLUTE)
230 if (injected_flags & LLMHF_INJECTED)
232 pt.x = (x * screen_width) >> 16;
233 pt.y = (y * screen_height) >> 16;
244 else if (flags & MOUSEEVENTF_MOVE)
246 int accel[3], xMult = 1, yMult = 1;
248 /* dx and dy can be negative numbers for relative movements */
249 SystemParametersInfoW(SPI_GETMOUSE, 0, accel, 0);
251 if (abs(x) > accel[0] && accel[2] != 0)
254 if ((abs(x) > accel[1]) && (accel[2] == 2)) xMult = 4;
256 if (abs(y) > accel[0] && accel[2] != 0)
259 if ((abs(y) > accel[1]) && (accel[2] == 2)) yMult = 4;
263 pt.x = cursor_pos.x + (long)x * xMult;
264 pt.y = cursor_pos.y + (long)y * yMult;
266 /* Clip to the current screen size */
267 if (pt.x < 0) pt.x = 0;
268 else if (pt.x >= screen_width) pt.x = screen_width - 1;
269 if (pt.y < 0) pt.y = 0;
270 else if (pt.y >= screen_height) pt.y = screen_height - 1;
281 if (flags & MOUSEEVENTF_MOVE)
283 queue_raw_mouse_message( WM_MOUSEMOVE, hwnd, pt.x, pt.y, data, time,
284 extra_info, injected_flags );
285 if ((injected_flags & LLMHF_INJECTED) &&
286 ((flags & MOUSEEVENTF_ABSOLUTE) || x || y)) /* we have to actually move the cursor */
288 TRACE( "warping to (%ld,%ld)\n", pt.x, pt.y );
290 XWarpPointer( thread_display(), root_window, root_window, 0, 0, 0, 0, pt.x, pt.y );
294 if (flags & MOUSEEVENTF_LEFTDOWN)
296 key_state_table[VK_LBUTTON] |= 0xc0;
297 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONDOWN : WM_LBUTTONDOWN,
298 hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
300 if (flags & MOUSEEVENTF_LEFTUP)
302 key_state_table[VK_LBUTTON] &= ~0x80;
303 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONUP : WM_LBUTTONUP,
304 hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
306 if (flags & MOUSEEVENTF_RIGHTDOWN)
308 key_state_table[VK_RBUTTON] |= 0xc0;
309 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONDOWN : WM_RBUTTONDOWN,
310 hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
312 if (flags & MOUSEEVENTF_RIGHTUP)
314 key_state_table[VK_RBUTTON] &= ~0x80;
315 queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONUP : WM_RBUTTONUP,
316 hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
318 if (flags & MOUSEEVENTF_MIDDLEDOWN)
320 key_state_table[VK_MBUTTON] |= 0xc0;
321 queue_raw_mouse_message( WM_MBUTTONDOWN, hwnd, pt.x, pt.y, data, time,
322 extra_info, injected_flags );
324 if (flags & MOUSEEVENTF_MIDDLEUP)
326 key_state_table[VK_MBUTTON] &= ~0x80;
327 queue_raw_mouse_message( WM_MBUTTONUP, hwnd, pt.x, pt.y, data, time,
328 extra_info, injected_flags );
330 if (flags & MOUSEEVENTF_WHEEL)
332 queue_raw_mouse_message( WM_MOUSEWHEEL, hwnd, pt.x, pt.y, data, time,
333 extra_info, injected_flags );
335 if (flags & MOUSEEVENTF_XDOWN)
337 key_state_table[VK_XBUTTON1 + data - 1] |= 0xc0;
338 queue_raw_mouse_message( WM_XBUTTONDOWN, hwnd, pt.x, pt.y, data, time,
339 extra_info, injected_flags );
341 if (flags & MOUSEEVENTF_XUP)
343 key_state_table[VK_XBUTTON1 + data - 1] &= ~0x80;
344 queue_raw_mouse_message( WM_XBUTTONUP, hwnd, pt.x, pt.y, data, time,
345 extra_info, injected_flags );
350 /***********************************************************************
353 * Create an X cursor from a Windows one.
355 static Cursor create_cursor( Display *display, CURSORICONINFO *ptr )
357 Pixmap pixmapBits, pixmapMask, pixmapMaskInv, pixmapAll;
359 Cursor cursor = None;
361 if (!ptr) /* Create an empty cursor */
363 static const char data[] = { 0 };
365 bg.red = bg.green = bg.blue = 0x0000;
366 pixmapBits = XCreateBitmapFromData( display, root_window, data, 1, 1 );
369 cursor = XCreatePixmapCursor( display, pixmapBits, pixmapBits,
371 XFreePixmap( display, pixmapBits );
374 else /* Create the X cursor from the bits */
379 TRACE("Bitmap %dx%d planes=%d bpp=%d bytesperline=%d\n",
380 ptr->nWidth, ptr->nHeight, ptr->bPlanes, ptr->bBitsPerPixel,
382 /* Create a pixmap and transfer all the bits to it */
384 /* NOTE: Following hack works, but only because XFree depth
385 * 1 images really use 1 bit/pixel (and so the same layout
386 * as the Windows cursor data). Perhaps use a more generic
389 /* This pixmap will be written with two bitmaps. The first is
390 * the mask and the second is the image.
392 if (!(pixmapAll = XCreatePixmap( display, root_window,
393 ptr->nWidth, ptr->nHeight * 2, 1 )))
395 if (!(image = XCreateImage( display, visual,
396 1, ZPixmap, 0, (char *)(ptr + 1), ptr->nWidth,
397 ptr->nHeight * 2, 16, ptr->nWidthBytes/ptr->bBitsPerPixel)))
399 XFreePixmap( display, pixmapAll );
402 gc = XCreateGC( display, pixmapAll, 0, NULL );
403 XSetGraphicsExposures( display, gc, False );
404 image->byte_order = MSBFirst;
405 image->bitmap_bit_order = MSBFirst;
406 image->bitmap_unit = 16;
407 _XInitImageFuncPtrs(image);
408 if (ptr->bPlanes * ptr->bBitsPerPixel == 1)
410 /* A plain old white on black cursor. */
411 fg.red = fg.green = fg.blue = 0xffff;
412 bg.red = bg.green = bg.blue = 0x0000;
413 XPutImage( display, pixmapAll, gc, image,
414 0, 0, 0, 0, ptr->nWidth, ptr->nHeight * 2 );
418 int rbits, gbits, bbits, red, green, blue;
419 int rfg, gfg, bfg, rbg, gbg, bbg;
420 int rscale, gscale, bscale;
421 int x, y, xmax, ymax, bitIndex, byteIndex, xorIndex;
422 unsigned char *theMask, *theImage, theChar;
423 int threshold, fgBits, bgBits, bitShifted;
424 BYTE pXorBits[128]; /* Up to 32x32 icons */
426 switch (ptr->bBitsPerPixel)
441 FIXME("Currently no support for cursors with %d bits per pixel\n",
443 XFreePixmap( display, pixmapAll );
444 XFreeGC( display, gc );
446 XDestroyImage( image );
449 /* The location of the mask. */
450 theMask = (unsigned char *)(ptr + 1);
451 /* The mask should still be 1 bit per pixel. The color image
452 * should immediately follow the mask.
454 theImage = &theMask[ptr->nWidth/8 * ptr->nHeight];
455 rfg = gfg = bfg = rbg = gbg = bbg = 0;
461 xmax = (ptr->nWidth > 32) ? 32 : ptr->nWidth;
462 if (ptr->nWidth > 32) {
463 ERR("Got a %dx%d cursor. Cannot handle larger than 32x32.\n",
464 ptr->nWidth, ptr->nHeight);
466 ymax = (ptr->nHeight > 32) ? 32 : ptr->nHeight;
468 memset(pXorBits, 0, 128);
469 for (y=0; y<ymax; y++)
471 for (x=0; x<xmax; x++)
473 red = green = blue = 0;
474 switch (ptr->bBitsPerPixel)
477 theChar = theImage[byteIndex++];
479 theChar = theImage[byteIndex++];
481 theChar = theImage[byteIndex++];
485 theChar = theImage[byteIndex++];
486 blue = theChar & 0x1F;
487 green = (theChar & 0xE0) >> 5;
488 theChar = theImage[byteIndex++];
489 green |= (theChar & 0x07) << 3;
490 red = (theChar & 0xF8) >> 3;
494 if (red+green+blue > threshold)
500 pXorBits[xorIndex] |= bitShifted;
514 bitShifted = bitShifted << 1;
517 rscale = 1 << (16 - rbits);
518 gscale = 1 << (16 - gbits);
519 bscale = 1 << (16 - bbits);
522 fg.red = rfg * rscale / fgBits;
523 fg.green = gfg * gscale / fgBits;
524 fg.blue = bfg * bscale / fgBits;
526 else fg.red = fg.green = fg.blue = 0;
527 bgBits = xmax * ymax - fgBits;
530 bg.red = rbg * rscale / bgBits;
531 bg.green = gbg * gscale / bgBits;
532 bg.blue = bbg * bscale / bgBits;
534 else bg.red = bg.green = bg.blue = 0;
535 pixmapBits = XCreateBitmapFromData( display, root_window, (char *)pXorBits, xmax, ymax );
538 XFreePixmap( display, pixmapAll );
539 XFreeGC( display, gc );
541 XDestroyImage( image );
546 XPutImage( display, pixmapAll, gc, image,
547 0, 0, 0, 0, ptr->nWidth, ptr->nHeight );
548 XSetFunction( display, gc, GXcopy );
550 XCopyArea( display, pixmapBits, pixmapAll, gc,
551 0, 0, xmax, ymax, 0, ptr->nHeight );
552 XFreePixmap( display, pixmapBits );
555 XDestroyImage( image );
557 /* Now create the 2 pixmaps for bits and mask */
559 pixmapBits = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 );
560 pixmapMask = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 );
561 pixmapMaskInv = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 );
563 /* Make sure everything went OK so far */
565 if (pixmapBits && pixmapMask && pixmapMaskInv)
569 /* We have to do some magic here, as cursors are not fully
570 * compatible between Windows and X11. Under X11, there
571 * are only 3 possible color cursor: black, white and
572 * masked. So we map the 4th Windows color (invert the
573 * bits on the screen) to black and an additional white bit on
574 * an other place (+1,+1). This require some boolean arithmetic:
577 * And Xor Result | Bits Mask Result
578 * 0 0 black | 0 1 background
579 * 0 1 white | 1 1 foreground
580 * 1 0 no change | X 0 no change
581 * 1 1 inverted | 0 1 background
584 * Bits = not 'And' and 'Xor' or 'And2' and 'Xor2'
585 * Mask = not 'And' or 'Xor' or 'And2' and 'Xor2'
587 * FIXME: apparently some servers do support 'inverted' color.
588 * I don't know if it's correct per the X spec, but maybe
589 * we ought to take advantage of it. -- AJ
591 XSetFunction( display, gc, GXcopy );
592 XCopyArea( display, pixmapAll, pixmapBits, gc,
593 0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
594 XCopyArea( display, pixmapAll, pixmapMask, gc,
595 0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
596 XCopyArea( display, pixmapAll, pixmapMaskInv, gc,
597 0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
598 XSetFunction( display, gc, GXand );
599 XCopyArea( display, pixmapAll, pixmapMaskInv, gc,
600 0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
601 XSetFunction( display, gc, GXandReverse );
602 XCopyArea( display, pixmapAll, pixmapBits, gc,
603 0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
604 XSetFunction( display, gc, GXorReverse );
605 XCopyArea( display, pixmapAll, pixmapMask, gc,
606 0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
607 /* Additional white */
608 XSetFunction( display, gc, GXor );
609 XCopyArea( display, pixmapMaskInv, pixmapMask, gc,
610 0, 0, ptr->nWidth, ptr->nHeight, 1, 1 );
611 XCopyArea( display, pixmapMaskInv, pixmapBits, gc,
612 0, 0, ptr->nWidth, ptr->nHeight, 1, 1 );
613 XSetFunction( display, gc, GXcopy );
615 /* Make sure hotspot is valid */
616 hotspot.x = ptr->ptHotSpot.x;
617 hotspot.y = ptr->ptHotSpot.y;
618 if (hotspot.x < 0 || hotspot.x >= ptr->nWidth ||
619 hotspot.y < 0 || hotspot.y >= ptr->nHeight)
621 hotspot.x = ptr->nWidth / 2;
622 hotspot.y = ptr->nHeight / 2;
624 cursor = XCreatePixmapCursor( display, pixmapBits, pixmapMask,
625 &fg, &bg, hotspot.x, hotspot.y );
628 /* Now free everything */
630 if (pixmapAll) XFreePixmap( display, pixmapAll );
631 if (pixmapBits) XFreePixmap( display, pixmapBits );
632 if (pixmapMask) XFreePixmap( display, pixmapMask );
633 if (pixmapMaskInv) XFreePixmap( display, pixmapMaskInv );
634 XFreeGC( display, gc );
640 /***********************************************************************
641 * SetCursor (X11DRV.@)
643 void X11DRV_SetCursor( CURSORICONINFO *lpCursor )
647 if (root_window != DefaultRootWindow(gdi_display))
649 /* If in desktop mode, set the cursor on the desktop window */
652 cursor = create_cursor( gdi_display, lpCursor );
655 XDefineCursor( gdi_display, root_window, cursor );
656 /* Make the change take effect immediately */
658 XFreeCursor( gdi_display, cursor );
662 else /* set the same cursor for all top-level windows of the current thread */
664 struct x11drv_thread_data *data = x11drv_thread_data();
667 cursor = create_cursor( data->display, lpCursor );
670 if (data->cursor) XFreeCursor( data->display, data->cursor );
671 data->cursor = cursor;
672 if (data->cursor_window)
674 XDefineCursor( data->display, data->cursor_window, cursor );
675 /* Make the change take effect immediately */
676 XFlush( data->display );
683 /***********************************************************************
684 * SetCursorPos (X11DRV.@)
686 BOOL X11DRV_SetCursorPos( INT x, INT y )
688 Display *display = thread_display();
690 TRACE( "warping to (%d,%d)\n", x, y );
693 XWarpPointer( display, root_window, root_window, 0, 0, 0, 0, x, y );
694 XFlush( display ); /* avoids bad mouse lag in games that do their own mouse warping */
701 /***********************************************************************
702 * GetCursorPos (X11DRV.@)
704 BOOL X11DRV_GetCursorPos(LPPOINT pos)
706 Display *display = thread_display();
708 int rootX, rootY, winX, winY;
712 if (XQueryPointer( display, root_window, &root, &child,
713 &rootX, &rootY, &winX, &winY, &xstate ))
715 update_key_state( xstate );
716 update_button_state( xstate );
717 TRACE("pointer at (%d,%d)\n", winX, winY );
726 /***********************************************************************
729 void X11DRV_ButtonPress( HWND hwnd, XEvent *xev )
731 XButtonEvent *event = &xev->xbutton;
732 int buttonNum = event->button - 1;
736 if (buttonNum >= NB_BUTTONS) return;
745 wData = -WHEEL_DELTA;
755 update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
757 X11DRV_send_mouse_input( hwnd, button_down_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE,
758 pt.x, pt.y, wData, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
762 /***********************************************************************
763 * X11DRV_ButtonRelease
765 void X11DRV_ButtonRelease( HWND hwnd, XEvent *xev )
767 XButtonEvent *event = &xev->xbutton;
768 int buttonNum = event->button - 1;
772 if (buttonNum >= NB_BUTTONS || !button_up_flags[buttonNum]) return;
785 update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
787 X11DRV_send_mouse_input( hwnd, button_up_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE,
788 pt.x, pt.y, wData, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
792 /***********************************************************************
793 * X11DRV_MotionNotify
795 void X11DRV_MotionNotify( HWND hwnd, XEvent *xev )
797 XMotionEvent *event = &xev->xmotion;
800 TRACE("hwnd %p, event->is_hint %d\n", hwnd, event->is_hint);
804 update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
806 X11DRV_send_mouse_input( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
807 pt.x, pt.y, 0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
811 /***********************************************************************
814 void X11DRV_EnterNotify( HWND hwnd, XEvent *xev )
816 XCrossingEvent *event = &xev->xcrossing;
819 TRACE("hwnd %p, event->detail %d\n", hwnd, event->detail);
822 if (event->detail == NotifyVirtual || event->detail == NotifyNonlinearVirtual) return;
824 /* simulate a mouse motion event */
825 update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
827 X11DRV_send_mouse_input( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
828 pt.x, pt.y, 0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );