git.oblomov.eu Git - wine/blob - dlls/winex11.drv/mouse.c

   1 /*
   2  * X11 mouse driver
   3  *
   4  * Copyright 1998 Ulrich Weigand
   5  *
   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.
  10  *
  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.
  15  *
  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
  19  */
  20
  21 #include "config.h"
  22
  23 #include <X11/Xlib.h>
  24 #include <stdarg.h>
  25
  26 #define NONAMELESSUNION
  27 #define NONAMELESSSTRUCT
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wine/winuser16.h"
  31
  32 #include "win.h"
  33 #include "x11drv.h"
  34 #include "wine/server.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(cursor);
  38
  39 /**********************************************************************/
  40
  41 #ifndef Button6Mask
  42 #define Button6Mask (1<<13)
  43 #endif
  44 #ifndef Button7Mask
  45 #define Button7Mask (1<<14)
  46 #endif
  47
  48 #define NB_BUTTONS   7     /* Windows can handle 5 buttons and the wheel too */
  49
  50 static const UINT button_down_flags[NB_BUTTONS] =
  51 {
  52     MOUSEEVENTF_LEFTDOWN,
  53     MOUSEEVENTF_MIDDLEDOWN,
  54     MOUSEEVENTF_RIGHTDOWN,
  55     MOUSEEVENTF_WHEEL,
  56     MOUSEEVENTF_WHEEL,
  57     MOUSEEVENTF_XDOWN,
  58     MOUSEEVENTF_XDOWN
  59 };
  60
  61 static const UINT button_up_flags[NB_BUTTONS] =
  62 {
  63     MOUSEEVENTF_LEFTUP,
  64     MOUSEEVENTF_MIDDLEUP,
  65     MOUSEEVENTF_RIGHTUP,
  66     0,
  67     0,
  68     MOUSEEVENTF_XUP,
  69     MOUSEEVENTF_XUP
  70 };
  71
  72 POINT cursor_pos;
  73 static DWORD last_time_modified;
  74 static RECT cursor_clip; /* Cursor clipping rect */
  75
  76 BOOL X11DRV_SetCursorPos( INT x, INT y );
  77
  78 /***********************************************************************
  79  *              get_coords
  80  *
  81  * get the coordinates of a mouse event
  82  */
  83 static inline void get_coords( HWND hwnd, int x, int y, POINT *pt )
  84 {
  85     struct x11drv_win_data *data = X11DRV_get_win_data( hwnd );
  86
  87     if (!data) return;
  88
  89     pt->x = x + data->whole_rect.left;
  90     pt->y = y + data->whole_rect.top;
  91 }
  92
  93 /***********************************************************************
  94  *              clip_point_to_rect
  95  *
  96  * Clip point to the provided rectangle
  97  */
  98 static inline void clip_point_to_rect( LPCRECT rect, LPPOINT pt )
  99 {
 100     if      (pt->x <  rect->left)   pt->x = rect->left;
 101     else if (pt->x >= rect->right)  pt->x = rect->right - 1;
 102     if      (pt->y <  rect->top)    pt->y = rect->top;
 103     else if (pt->y >= rect->bottom) pt->y = rect->bottom - 1;
 104 }
 105
 106 /***********************************************************************
 107  *              update_button_state
 108  *
 109  * Update the button state with what X provides us
 110  */
 111 static inline void update_button_state( unsigned int state )
 112 {
 113     key_state_table[VK_LBUTTON] = (state & Button1Mask ? 0x80 : 0);
 114     key_state_table[VK_MBUTTON] = (state & Button2Mask ? 0x80 : 0);
 115     key_state_table[VK_RBUTTON] = (state & Button3Mask ? 0x80 : 0);
 116     /* X-buttons are not reported from XQueryPointer */
 117 }
 118
 119
 120 /***********************************************************************
 121  *              update_mouse_state
 122  *
 123  * Update the various window states on a mouse event.
 124  */
 125 static void update_mouse_state( HWND hwnd, Window window, int x, int y, unsigned int state, POINT *pt )
 126 {
 127     struct x11drv_thread_data *data = x11drv_thread_data();
 128
 129     if (window == root_window)
 130     {
 131         x += virtual_screen_rect.left;
 132         y += virtual_screen_rect.top;
 133     }
 134     get_coords( hwnd, x, y, pt );
 135
 136     /* update the cursor */
 137
 138     if (data->cursor_window != window)
 139     {
 140         data->cursor_window = window;
 141         wine_tsx11_lock();
 142         if (data->cursor) XDefineCursor( data->display, window, data->cursor );
 143         wine_tsx11_unlock();
 144     }
 145
 146     /* update the wine server Z-order */
 147
 148     if (window != data->grab_window &&
 149         /* ignore event if a button is pressed, since the mouse is then grabbed too */
 150         !(state & (Button1Mask|Button2Mask|Button3Mask|Button4Mask|Button5Mask|Button6Mask|Button7Mask)))
 151     {
 152         SERVER_START_REQ( update_window_zorder )
 153         {
 154             req->window      = hwnd;
 155             req->rect.left   = pt->x;
 156             req->rect.top    = pt->y;
 157             req->rect.right  = pt->x + 1;
 158             req->rect.bottom = pt->y + 1;
 159             wine_server_call( req );
 160         }
 161         SERVER_END_REQ;
 162     }
 163 }
 164
 165
 166 /***********************************************************************
 167  *           get_key_state
 168  */
 169 static WORD get_key_state(void)
 170 {
 171     WORD ret = 0;
 172
 173     if (GetSystemMetrics( SM_SWAPBUTTON ))
 174     {
 175         if (key_state_table[VK_RBUTTON] & 0x80) ret |= MK_LBUTTON;
 176         if (key_state_table[VK_LBUTTON] & 0x80) ret |= MK_RBUTTON;
 177     }
 178     else
 179     {
 180         if (key_state_table[VK_LBUTTON] & 0x80) ret |= MK_LBUTTON;
 181         if (key_state_table[VK_RBUTTON] & 0x80) ret |= MK_RBUTTON;
 182     }
 183     if (key_state_table[VK_MBUTTON] & 0x80)  ret |= MK_MBUTTON;
 184     if (key_state_table[VK_SHIFT] & 0x80)    ret |= MK_SHIFT;
 185     if (key_state_table[VK_CONTROL] & 0x80)  ret |= MK_CONTROL;
 186     if (key_state_table[VK_XBUTTON1] & 0x80) ret |= MK_XBUTTON1;
 187     if (key_state_table[VK_XBUTTON2] & 0x80) ret |= MK_XBUTTON2;
 188     return ret;
 189 }
 190
 191
 192 /***********************************************************************
 193  *           queue_raw_mouse_message
 194  */
 195 static void queue_raw_mouse_message( UINT message, HWND hwnd, DWORD x, DWORD y,
 196                                      DWORD data, DWORD time, DWORD extra_info, UINT injected_flags )
 197 {
 198     MSLLHOOKSTRUCT hook;
 199
 200     hook.pt.x        = x;
 201     hook.pt.y        = y;
 202     hook.mouseData   = MAKELONG( 0, data );
 203     hook.flags       = injected_flags;
 204     hook.time        = time;
 205     hook.dwExtraInfo = extra_info;
 206
 207     last_time_modified = GetTickCount();
 208     if (HOOK_CallHooks( WH_MOUSE_LL, HC_ACTION, message, (LPARAM)&hook, TRUE )) return;
 209
 210     SERVER_START_REQ( send_hardware_message )
 211     {
 212         req->id       = (injected_flags & LLMHF_INJECTED) ? 0 : GetCurrentThreadId();
 213         req->win      = hwnd;
 214         req->msg      = message;
 215         req->wparam   = MAKEWPARAM( get_key_state(), data );
 216         req->lparam   = 0;
 217         req->x        = x;
 218         req->y        = y;
 219         req->time     = time;
 220         req->info     = extra_info;
 221         wine_server_call( req );
 222     }
 223     SERVER_END_REQ;
 224
 225 }
 226
 227
 228 /***********************************************************************
 229  *              X11DRV_send_mouse_input
 230  */
 231 void X11DRV_send_mouse_input( HWND hwnd, DWORD flags, DWORD x, DWORD y,
 232                               DWORD data, DWORD time, DWORD extra_info, UINT injected_flags )
 233 {
 234     POINT pt;
 235
 236     if (flags & MOUSEEVENTF_MOVE && flags & MOUSEEVENTF_ABSOLUTE)
 237     {
 238         if (injected_flags & LLMHF_INJECTED)
 239         {
 240             pt.x = (x * screen_width) >> 16;
 241             pt.y = (y * screen_height) >> 16;
 242         }
 243         else
 244         {
 245             pt.x = x;
 246             pt.y = y;
 247             wine_tsx11_lock();
 248             if (cursor_pos.x == x && cursor_pos.y == y) flags &= ~MOUSEEVENTF_MOVE;
 249             wine_tsx11_unlock();
 250         }
 251     }
 252     else if (flags & MOUSEEVENTF_MOVE)
 253     {
 254         int accel[3], xMult = 1, yMult = 1;
 255
 256         /* dx and dy can be negative numbers for relative movements */
 257         SystemParametersInfoW(SPI_GETMOUSE, 0, accel, 0);
 258
 259         if (abs(x) > accel[0] && accel[2] != 0)
 260         {
 261             xMult = 2;
 262             if ((abs(x) > accel[1]) && (accel[2] == 2)) xMult = 4;
 263         }
 264         if (abs(y) > accel[0] && accel[2] != 0)
 265         {
 266             yMult = 2;
 267             if ((abs(y) > accel[1]) && (accel[2] == 2)) yMult = 4;
 268         }
 269
 270         wine_tsx11_lock();
 271         pt.x = cursor_pos.x + (long)x * xMult;
 272         pt.y = cursor_pos.y + (long)y * yMult;
 273         wine_tsx11_unlock();
 274     }
 275     else
 276     {
 277         wine_tsx11_lock();
 278         pt = cursor_pos;
 279         wine_tsx11_unlock();
 280     }
 281
 282     if (flags & MOUSEEVENTF_MOVE)
 283     {
 284         queue_raw_mouse_message( WM_MOUSEMOVE, hwnd, pt.x, pt.y, data, time,
 285                                  extra_info, injected_flags );
 286         if ((injected_flags & LLMHF_INJECTED) &&
 287             ((flags & MOUSEEVENTF_ABSOLUTE) || x || y))  /* we have to actually move the cursor */
 288         {
 289             X11DRV_SetCursorPos( pt.x, pt.y );
 290         }
 291         else
 292         {
 293             wine_tsx11_lock();
 294             clip_point_to_rect( &cursor_clip, &pt);
 295             cursor_pos = pt;
 296             wine_tsx11_unlock();
 297         }
 298     }
 299     if (flags & MOUSEEVENTF_LEFTDOWN)
 300     {
 301         key_state_table[VK_LBUTTON] |= 0xc0;
 302         queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONDOWN : WM_LBUTTONDOWN,
 303                                  hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
 304     }
 305     if (flags & MOUSEEVENTF_LEFTUP)
 306     {
 307         key_state_table[VK_LBUTTON] &= ~0x80;
 308         queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONUP : WM_LBUTTONUP,
 309                                  hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
 310     }
 311     if (flags & MOUSEEVENTF_RIGHTDOWN)
 312     {
 313         key_state_table[VK_RBUTTON] |= 0xc0;
 314         queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONDOWN : WM_RBUTTONDOWN,
 315                                  hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
 316     }
 317     if (flags & MOUSEEVENTF_RIGHTUP)
 318     {
 319         key_state_table[VK_RBUTTON] &= ~0x80;
 320         queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONUP : WM_RBUTTONUP,
 321                                  hwnd, pt.x, pt.y, data, time, extra_info, injected_flags );
 322     }
 323     if (flags & MOUSEEVENTF_MIDDLEDOWN)
 324     {
 325         key_state_table[VK_MBUTTON] |= 0xc0;
 326         queue_raw_mouse_message( WM_MBUTTONDOWN, hwnd, pt.x, pt.y, data, time,
 327                                  extra_info, injected_flags );
 328     }
 329     if (flags & MOUSEEVENTF_MIDDLEUP)
 330     {
 331         key_state_table[VK_MBUTTON] &= ~0x80;
 332         queue_raw_mouse_message( WM_MBUTTONUP, hwnd, pt.x, pt.y, data, time,
 333                                  extra_info, injected_flags );
 334     }
 335     if (flags & MOUSEEVENTF_WHEEL)
 336     {
 337         queue_raw_mouse_message( WM_MOUSEWHEEL, hwnd, pt.x, pt.y, data, time,
 338                                  extra_info, injected_flags );
 339     }
 340     if (flags & MOUSEEVENTF_XDOWN)
 341     {
 342         key_state_table[VK_XBUTTON1 + data - 1] |= 0xc0;
 343         queue_raw_mouse_message( WM_XBUTTONDOWN, hwnd, pt.x, pt.y, data, time,
 344                                  extra_info, injected_flags );
 345     }
 346     if (flags & MOUSEEVENTF_XUP)
 347     {
 348         key_state_table[VK_XBUTTON1 + data - 1] &= ~0x80;
 349         queue_raw_mouse_message( WM_XBUTTONUP, hwnd, pt.x, pt.y, data, time,
 350                                  extra_info, injected_flags );
 351     }
 352 }
 353
 354
 355 /***********************************************************************
 356  *              create_cursor
 357  *
 358  * Create an X cursor from a Windows one.
 359  */
 360 static Cursor create_cursor( Display *display, CURSORICONINFO *ptr )
 361 {
 362     Pixmap pixmapBits, pixmapMask, pixmapMaskInv, pixmapAll;
 363     XColor fg, bg;
 364     Cursor cursor = None;
 365
 366     if (!ptr)  /* Create an empty cursor */
 367     {
 368         static const char data[] = { 0 };
 369
 370         bg.red = bg.green = bg.blue = 0x0000;
 371         pixmapBits = XCreateBitmapFromData( display, root_window, data, 1, 1 );
 372         if (pixmapBits)
 373         {
 374             cursor = XCreatePixmapCursor( display, pixmapBits, pixmapBits,
 375                                           &bg, &bg, 0, 0 );
 376             XFreePixmap( display, pixmapBits );
 377         }
 378     }
 379     else  /* Create the X cursor from the bits */
 380     {
 381         XImage *image;
 382         GC gc;
 383
 384         TRACE("Bitmap %dx%d planes=%d bpp=%d bytesperline=%d\n",
 385             ptr->nWidth, ptr->nHeight, ptr->bPlanes, ptr->bBitsPerPixel,
 386             ptr->nWidthBytes);
 387         /* Create a pixmap and transfer all the bits to it */
 388
 389         /* NOTE: Following hack works, but only because XFree depth
 390          *       1 images really use 1 bit/pixel (and so the same layout
 391          *       as the Windows cursor data). Perhaps use a more generic
 392          *       algorithm here.
 393          */
 394         /* This pixmap will be written with two bitmaps. The first is
 395          *  the mask and the second is the image.
 396          */
 397         if (!(pixmapAll = XCreatePixmap( display, root_window,
 398                   ptr->nWidth, ptr->nHeight * 2, 1 )))
 399             return 0;
 400         if (!(image = XCreateImage( display, visual,
 401                 1, ZPixmap, 0, (char *)(ptr + 1), ptr->nWidth,
 402                 ptr->nHeight * 2, 16, ptr->nWidthBytes/ptr->bBitsPerPixel)))
 403         {
 404             XFreePixmap( display, pixmapAll );
 405             return 0;
 406         }
 407         gc = XCreateGC( display, pixmapAll, 0, NULL );
 408         XSetGraphicsExposures( display, gc, False );
 409         image->byte_order = MSBFirst;
 410         image->bitmap_bit_order = MSBFirst;
 411         image->bitmap_unit = 16;
 412         _XInitImageFuncPtrs(image);
 413         if (ptr->bPlanes * ptr->bBitsPerPixel == 1)
 414         {
 415             /* A plain old white on black cursor. */
 416             fg.red = fg.green = fg.blue = 0xffff;
 417             bg.red = bg.green = bg.blue = 0x0000;
 418             XPutImage( display, pixmapAll, gc, image,
 419                 0, 0, 0, 0, ptr->nWidth, ptr->nHeight * 2 );
 420         }
 421         else
 422         {
 423             int     rbits, gbits, bbits, red, green, blue;
 424             int     rfg, gfg, bfg, rbg, gbg, bbg;
 425             int     rscale, gscale, bscale;
 426             int     x, y, xmax, ymax, bitIndex, byteIndex, xorIndex;
 427             unsigned char *theMask, *theImage, theChar;
 428             int     threshold, fgBits, bgBits, bitShifted;
 429             BYTE    pXorBits[128];   /* Up to 32x32 icons */
 430
 431             switch (ptr->bBitsPerPixel)
 432             {
 433             case 24:
 434                 rbits = 8;
 435                 gbits = 8;
 436                 bbits = 8;
 437                 threshold = 0x40;
 438                 break;
 439             case 16:
 440                 rbits = 5;
 441                 gbits = 6;
 442                 bbits = 5;
 443                 threshold = 0x40;
 444                 break;
 445             default:
 446                 FIXME("Currently no support for cursors with %d bits per pixel\n",
 447                   ptr->bBitsPerPixel);
 448                 XFreePixmap( display, pixmapAll );
 449                 XFreeGC( display, gc );
 450                 image->data = NULL;
 451                 XDestroyImage( image );
 452                 return 0;
 453             }
 454             /* The location of the mask. */
 455             theMask = (unsigned char *)(ptr + 1);
 456             /* The mask should still be 1 bit per pixel. The color image
 457              * should immediately follow the mask.
 458              */
 459             theImage = &theMask[ptr->nWidth/8 * ptr->nHeight];
 460             rfg = gfg = bfg = rbg = gbg = bbg = 0;
 461             bitIndex = 0;
 462             byteIndex = 0;
 463             xorIndex = 0;
 464             fgBits = 0;
 465             bitShifted = 0x01;
 466             xmax = (ptr->nWidth > 32) ? 32 : ptr->nWidth;
 467             if (ptr->nWidth > 32) {
 468                 ERR("Got a %dx%d cursor. Cannot handle larger than 32x32.\n",
 469                   ptr->nWidth, ptr->nHeight);
 470             }
 471             ymax = (ptr->nHeight > 32) ? 32 : ptr->nHeight;
 472
 473             memset(pXorBits, 0, 128);
 474             for (y=0; y<ymax; y++)
 475             {
 476                 for (x=0; x<xmax; x++)
 477                 {
 478                         red = green = blue = 0;
 479                         switch (ptr->bBitsPerPixel)
 480                         {
 481                         case 24:
 482                             theChar = theImage[byteIndex++];
 483                             blue = theChar;
 484                             theChar = theImage[byteIndex++];
 485                             green = theChar;
 486                             theChar = theImage[byteIndex++];
 487                             red = theChar;
 488                             break;
 489                         case 16:
 490                             theChar = theImage[byteIndex++];
 491                             blue = theChar & 0x1F;
 492                             green = (theChar & 0xE0) >> 5;
 493                             theChar = theImage[byteIndex++];
 494                             green |= (theChar & 0x07) << 3;
 495                             red = (theChar & 0xF8) >> 3;
 496                             break;
 497                         }
 498
 499                     if (red+green+blue > threshold)
 500                     {
 501                         rfg += red;
 502                         gfg += green;
 503                         bfg += blue;
 504                         fgBits++;
 505                         pXorBits[xorIndex] |= bitShifted;
 506                     }
 507                     else
 508                     {
 509                         rbg += red;
 510                         gbg += green;
 511                         bbg += blue;
 512                     }
 513                     if (x%8 == 7)
 514                     {
 515                         bitShifted = 0x01;
 516                         xorIndex++;
 517                     }
 518                     else
 519                         bitShifted = bitShifted << 1;
 520                 }
 521             }
 522             rscale = 1 << (16 - rbits);
 523             gscale = 1 << (16 - gbits);
 524             bscale = 1 << (16 - bbits);
 525             if (fgBits)
 526             {
 527                 fg.red   = rfg * rscale / fgBits;
 528                 fg.green = gfg * gscale / fgBits;
 529                 fg.blue  = bfg * bscale / fgBits;
 530             }
 531             else fg.red = fg.green = fg.blue = 0;
 532             bgBits = xmax * ymax - fgBits;
 533             if (bgBits)
 534             {
 535                 bg.red   = rbg * rscale / bgBits;
 536                 bg.green = gbg * gscale / bgBits;
 537                 bg.blue  = bbg * bscale / bgBits;
 538             }
 539             else bg.red = bg.green = bg.blue = 0;
 540             pixmapBits = XCreateBitmapFromData( display, root_window, (char *)pXorBits, xmax, ymax );
 541             if (!pixmapBits)
 542             {
 543                 XFreePixmap( display, pixmapAll );
 544                 XFreeGC( display, gc );
 545                 image->data = NULL;
 546                 XDestroyImage( image );
 547                 return 0;
 548             }
 549
 550             /* Put the mask. */
 551             XPutImage( display, pixmapAll, gc, image,
 552                    0, 0, 0, 0, ptr->nWidth, ptr->nHeight );
 553             XSetFunction( display, gc, GXcopy );
 554             /* Put the image */
 555             XCopyArea( display, pixmapBits, pixmapAll, gc,
 556                        0, 0, xmax, ymax, 0, ptr->nHeight );
 557             XFreePixmap( display, pixmapBits );
 558         }
 559         image->data = NULL;
 560         XDestroyImage( image );
 561
 562         /* Now create the 2 pixmaps for bits and mask */
 563
 564         pixmapBits = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 );
 565         pixmapMask = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 );
 566         pixmapMaskInv = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 );
 567
 568         /* Make sure everything went OK so far */
 569
 570         if (pixmapBits && pixmapMask && pixmapMaskInv)
 571         {
 572             POINT hotspot;
 573
 574             /* We have to do some magic here, as cursors are not fully
 575              * compatible between Windows and X11. Under X11, there
 576              * are only 3 possible color cursor: black, white and
 577              * masked. So we map the 4th Windows color (invert the
 578              * bits on the screen) to black and an additional white bit on
 579              * an other place (+1,+1). This require some boolean arithmetic:
 580              *
 581              *         Windows          |          X11
 582              * And    Xor      Result   |   Bits     Mask     Result
 583              *  0      0     black      |    0        1     background
 584              *  0      1     white      |    1        1     foreground
 585              *  1      0     no change  |    X        0     no change
 586              *  1      1     inverted   |    0        1     background
 587              *
 588              * which gives:
 589              *  Bits = not 'And' and 'Xor' or 'And2' and 'Xor2'
 590              *  Mask = not 'And' or 'Xor' or 'And2' and 'Xor2'
 591              *
 592              * FIXME: apparently some servers do support 'inverted' color.
 593              * I don't know if it's correct per the X spec, but maybe
 594              * we ought to take advantage of it.  -- AJ
 595              */
 596             XSetFunction( display, gc, GXcopy );
 597             XCopyArea( display, pixmapAll, pixmapBits, gc,
 598                        0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
 599             XCopyArea( display, pixmapAll, pixmapMask, gc,
 600                        0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
 601             XCopyArea( display, pixmapAll, pixmapMaskInv, gc,
 602                        0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
 603             XSetFunction( display, gc, GXand );
 604             XCopyArea( display, pixmapAll, pixmapMaskInv, gc,
 605                        0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
 606             XSetFunction( display, gc, GXandReverse );
 607             XCopyArea( display, pixmapAll, pixmapBits, gc,
 608                        0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
 609             XSetFunction( display, gc, GXorReverse );
 610             XCopyArea( display, pixmapAll, pixmapMask, gc,
 611                        0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
 612             /* Additional white */
 613             XSetFunction( display, gc, GXor );
 614             XCopyArea( display, pixmapMaskInv, pixmapMask, gc,
 615                        0, 0, ptr->nWidth, ptr->nHeight, 1, 1 );
 616             XCopyArea( display, pixmapMaskInv, pixmapBits, gc,
 617                        0, 0, ptr->nWidth, ptr->nHeight, 1, 1 );
 618             XSetFunction( display, gc, GXcopy );
 619
 620             /* Make sure hotspot is valid */
 621             hotspot.x = ptr->ptHotSpot.x;
 622             hotspot.y = ptr->ptHotSpot.y;
 623             if (hotspot.x < 0 || hotspot.x >= ptr->nWidth ||
 624                 hotspot.y < 0 || hotspot.y >= ptr->nHeight)
 625             {
 626                 hotspot.x = ptr->nWidth / 2;
 627                 hotspot.y = ptr->nHeight / 2;
 628             }
 629             cursor = XCreatePixmapCursor( display, pixmapBits, pixmapMask,
 630                                           &fg, &bg, hotspot.x, hotspot.y );
 631         }
 632
 633         /* Now free everything */
 634
 635         if (pixmapAll) XFreePixmap( display, pixmapAll );
 636         if (pixmapBits) XFreePixmap( display, pixmapBits );
 637         if (pixmapMask) XFreePixmap( display, pixmapMask );
 638         if (pixmapMaskInv) XFreePixmap( display, pixmapMaskInv );
 639         XFreeGC( display, gc );
 640     }
 641     return cursor;
 642 }
 643
 644
 645 /***********************************************************************
 646  *              SetCursor (X11DRV.@)
 647  */
 648 void X11DRV_SetCursor( CURSORICONINFO *lpCursor )
 649 {
 650     Cursor cursor;
 651
 652     if (root_window != DefaultRootWindow(gdi_display))
 653     {
 654         /* If in desktop mode, set the cursor on the desktop window */
 655
 656         wine_tsx11_lock();
 657         cursor = create_cursor( gdi_display, lpCursor );
 658         if (cursor)
 659         {
 660             XDefineCursor( gdi_display, root_window, cursor );
 661             /* Make the change take effect immediately */
 662             XFlush(gdi_display);
 663             XFreeCursor( gdi_display, cursor );
 664         }
 665         wine_tsx11_unlock();
 666     }
 667     else /* set the same cursor for all top-level windows of the current thread */
 668     {
 669         struct x11drv_thread_data *data = x11drv_thread_data();
 670
 671         wine_tsx11_lock();
 672         cursor = create_cursor( data->display, lpCursor );
 673         if (cursor)
 674         {
 675             if (data->cursor) XFreeCursor( data->display, data->cursor );
 676             data->cursor = cursor;
 677             if (data->cursor_window)
 678             {
 679                 XDefineCursor( data->display, data->cursor_window, cursor );
 680                 /* Make the change take effect immediately */
 681                 XFlush( data->display );
 682             }
 683         }
 684         wine_tsx11_unlock();
 685     }
 686 }
 687
 688 /***********************************************************************
 689  *              SetCursorPos (X11DRV.@)
 690  */
 691 BOOL X11DRV_SetCursorPos( INT x, INT y )
 692 {
 693     Display *display = thread_display();
 694     POINT pt;
 695
 696     TRACE( "warping to (%d,%d)\n", x, y );
 697
 698     wine_tsx11_lock();
 699     if (cursor_pos.x == x && cursor_pos.y == y)
 700     {
 701         wine_tsx11_unlock();
 702         /* We still need to generate WM_MOUSEMOVE */
 703         queue_raw_mouse_message( WM_MOUSEMOVE, NULL, x, y, 0, GetCurrentTime(), 0, 0 );
 704         return TRUE;
 705     }
 706
 707     pt.x = x; pt.y = y;
 708     clip_point_to_rect( &cursor_clip, &pt);
 709     XWarpPointer( display, root_window, root_window, 0, 0, 0, 0,
 710                   pt.x - virtual_screen_rect.left, pt.y - virtual_screen_rect.top );
 711     XFlush( display ); /* avoids bad mouse lag in games that do their own mouse warping */
 712     cursor_pos = pt;
 713     wine_tsx11_unlock();
 714     return TRUE;
 715 }
 716
 717 /***********************************************************************
 718  *              GetCursorPos (X11DRV.@)
 719  */
 720 BOOL X11DRV_GetCursorPos(LPPOINT pos)
 721 {
 722     Display *display = thread_display();
 723     Window root, child;
 724     int rootX, rootY, winX, winY;
 725     unsigned int xstate;
 726
 727     wine_tsx11_lock();
 728     if ((GetTickCount() - last_time_modified > 100) &&
 729         XQueryPointer( display, root_window, &root, &child,
 730                        &rootX, &rootY, &winX, &winY, &xstate ))
 731     {
 732         update_button_state( xstate );
 733         winX += virtual_screen_rect.left;
 734         winY += virtual_screen_rect.top;
 735         TRACE("pointer at (%d,%d)\n", winX, winY );
 736         cursor_pos.x = winX;
 737         cursor_pos.y = winY;
 738     }
 739     *pos = cursor_pos;
 740     wine_tsx11_unlock();
 741     return TRUE;
 742 }
 743
 744
 745 /***********************************************************************
 746  *              ClipCursor (X11DRV.@)
 747  *
 748  * Set the cursor clipping rectangle.
 749  */
 750 BOOL X11DRV_ClipCursor( LPCRECT clip )
 751 {
 752     if (!IntersectRect( &cursor_clip, &virtual_screen_rect, clip ))
 753         cursor_clip = virtual_screen_rect;
 754
 755     return TRUE;
 756 }
 757
 758 /***********************************************************************
 759  *           X11DRV_ButtonPress
 760  */
 761 void X11DRV_ButtonPress( HWND hwnd, XEvent *xev )
 762 {
 763     XButtonEvent *event = &xev->xbutton;
 764     int buttonNum = event->button - 1;
 765     WORD wData = 0;
 766     POINT pt;
 767
 768     if (buttonNum >= NB_BUTTONS) return;
 769     if (!hwnd) return;
 770
 771     switch (buttonNum)
 772     {
 773     case 3:
 774         wData = WHEEL_DELTA;
 775         break;
 776     case 4:
 777         wData = -WHEEL_DELTA;
 778         break;
 779     case 5:
 780         wData = XBUTTON1;
 781         break;
 782     case 6:
 783         wData = XBUTTON2;
 784         break;
 785     }
 786
 787     update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
 788
 789     X11DRV_send_mouse_input( hwnd, button_down_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE,
 790                              pt.x, pt.y, wData, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
 791 }
 792
 793
 794 /***********************************************************************
 795  *           X11DRV_ButtonRelease
 796  */
 797 void X11DRV_ButtonRelease( HWND hwnd, XEvent *xev )
 798 {
 799     XButtonEvent *event = &xev->xbutton;
 800     int buttonNum = event->button - 1;
 801     WORD wData = 0;
 802     POINT pt;
 803
 804     if (buttonNum >= NB_BUTTONS || !button_up_flags[buttonNum]) return;
 805     if (!hwnd) return;
 806
 807     switch (buttonNum)
 808     {
 809     case 5:
 810         wData = XBUTTON1;
 811         break;
 812     case 6:
 813         wData = XBUTTON2;
 814         break;
 815     }
 816
 817     update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
 818
 819     X11DRV_send_mouse_input( hwnd, button_up_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE,
 820                              pt.x, pt.y, wData, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
 821 }
 822
 823
 824 /***********************************************************************
 825  *           X11DRV_MotionNotify
 826  */
 827 void X11DRV_MotionNotify( HWND hwnd, XEvent *xev )
 828 {
 829     XMotionEvent *event = &xev->xmotion;
 830     POINT pt;
 831
 832     TRACE("hwnd %p, event->is_hint %d\n", hwnd, event->is_hint);
 833
 834     if (!hwnd) return;
 835
 836     update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
 837
 838     X11DRV_send_mouse_input( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
 839                              pt.x, pt.y, 0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
 840 }
 841
 842
 843 /***********************************************************************
 844  *           X11DRV_EnterNotify
 845  */
 846 void X11DRV_EnterNotify( HWND hwnd, XEvent *xev )
 847 {
 848     XCrossingEvent *event = &xev->xcrossing;
 849     POINT pt;
 850
 851     TRACE("hwnd %p, event->detail %d\n", hwnd, event->detail);
 852
 853     if (!hwnd) return;
 854     if (event->detail == NotifyVirtual || event->detail == NotifyNonlinearVirtual) return;
 855
 856     /* simulate a mouse motion event */
 857     update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt );
 858
 859     X11DRV_send_mouse_input( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
 860                              pt.x, pt.y, 0, EVENT_x11_time_to_win32_time(event->time), 0, 0 );
 861 }