| /* |
| * X11 mouse driver |
| * |
| * Copyright 1998 Ulrich Weigand |
| * Copyright 2007 Henri Verbeet |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <X11/Xlib.h> |
| #include <stdarg.h> |
| |
| #ifdef SONAME_LIBXCURSOR |
| # include <X11/Xcursor/Xcursor.h> |
| static void *xcursor_handle; |
| # define MAKE_FUNCPTR(f) static typeof(f) * p##f |
| MAKE_FUNCPTR(XcursorImageCreate); |
| MAKE_FUNCPTR(XcursorImageDestroy); |
| MAKE_FUNCPTR(XcursorImageLoadCursor); |
| # undef MAKE_FUNCPTR |
| #endif /* SONAME_LIBXCURSOR */ |
| |
| #define NONAMELESSUNION |
| #define NONAMELESSSTRUCT |
| #include "windef.h" |
| #include "winbase.h" |
| #include "wine/winuser16.h" |
| |
| #include "win.h" |
| #include "x11drv.h" |
| #include "wine/server.h" |
| #include "wine/library.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(cursor); |
| |
| /**********************************************************************/ |
| |
| #ifndef Button6Mask |
| #define Button6Mask (1<<13) |
| #endif |
| #ifndef Button7Mask |
| #define Button7Mask (1<<14) |
| #endif |
| |
| #define NB_BUTTONS 7 /* Windows can handle 5 buttons and the wheel too */ |
| |
| static const UINT button_down_flags[NB_BUTTONS] = |
| { |
| MOUSEEVENTF_LEFTDOWN, |
| MOUSEEVENTF_MIDDLEDOWN, |
| MOUSEEVENTF_RIGHTDOWN, |
| MOUSEEVENTF_WHEEL, |
| MOUSEEVENTF_WHEEL, |
| MOUSEEVENTF_XDOWN, |
| MOUSEEVENTF_XDOWN |
| }; |
| |
| static const UINT button_up_flags[NB_BUTTONS] = |
| { |
| MOUSEEVENTF_LEFTUP, |
| MOUSEEVENTF_MIDDLEUP, |
| MOUSEEVENTF_RIGHTUP, |
| 0, |
| 0, |
| MOUSEEVENTF_XUP, |
| MOUSEEVENTF_XUP |
| }; |
| |
| POINT cursor_pos; |
| static DWORD last_time_modified; |
| static RECT cursor_clip; /* Cursor clipping rect */ |
| |
| BOOL X11DRV_SetCursorPos( INT x, INT y ); |
| |
| |
| /*********************************************************************** |
| * X11DRV_Xcursor_Init |
| * |
| * Load the Xcursor library for use. |
| */ |
| void X11DRV_Xcursor_Init(void) |
| { |
| #ifdef SONAME_LIBXCURSOR |
| xcursor_handle = wine_dlopen(SONAME_LIBXCURSOR, RTLD_NOW, NULL, 0); |
| if (!xcursor_handle) /* wine_dlopen failed. */ |
| { |
| WARN("Xcursor failed to load. Using fallback code.\n"); |
| return; |
| } |
| #define LOAD_FUNCPTR(f) \ |
| p##f = wine_dlsym(xcursor_handle, #f, NULL, 0) |
| |
| LOAD_FUNCPTR(XcursorImageCreate); |
| LOAD_FUNCPTR(XcursorImageDestroy); |
| LOAD_FUNCPTR(XcursorImageLoadCursor); |
| #undef LOAD_FUNCPTR |
| #endif /* SONAME_LIBXCURSOR */ |
| } |
| |
| |
| /*********************************************************************** |
| * get_coords |
| * |
| * get the coordinates of a mouse event |
| */ |
| static inline void get_coords( HWND hwnd, int x, int y, POINT *pt ) |
| { |
| struct x11drv_win_data *data = X11DRV_get_win_data( hwnd ); |
| |
| if (!data) return; |
| |
| pt->x = x + data->whole_rect.left; |
| pt->y = y + data->whole_rect.top; |
| } |
| |
| /*********************************************************************** |
| * clip_point_to_rect |
| * |
| * Clip point to the provided rectangle |
| */ |
| static inline void clip_point_to_rect( LPCRECT rect, LPPOINT pt ) |
| { |
| if (pt->x < rect->left) pt->x = rect->left; |
| else if (pt->x >= rect->right) pt->x = rect->right - 1; |
| if (pt->y < rect->top) pt->y = rect->top; |
| else if (pt->y >= rect->bottom) pt->y = rect->bottom - 1; |
| } |
| |
| /*********************************************************************** |
| * update_button_state |
| * |
| * Update the button state with what X provides us |
| */ |
| static inline void update_button_state( unsigned int state ) |
| { |
| key_state_table[VK_LBUTTON] = (state & Button1Mask ? 0x80 : 0); |
| key_state_table[VK_MBUTTON] = (state & Button2Mask ? 0x80 : 0); |
| key_state_table[VK_RBUTTON] = (state & Button3Mask ? 0x80 : 0); |
| /* X-buttons are not reported from XQueryPointer */ |
| } |
| |
| |
| /*********************************************************************** |
| * update_mouse_state |
| * |
| * Update the various window states on a mouse event. |
| */ |
| static void update_mouse_state( HWND hwnd, Window window, int x, int y, unsigned int state, POINT *pt ) |
| { |
| struct x11drv_thread_data *data = x11drv_thread_data(); |
| |
| if (window == root_window) |
| { |
| x += virtual_screen_rect.left; |
| y += virtual_screen_rect.top; |
| } |
| get_coords( hwnd, x, y, pt ); |
| |
| /* update the cursor */ |
| |
| if (data->cursor_window != window) |
| { |
| data->cursor_window = window; |
| wine_tsx11_lock(); |
| if (data->cursor) XDefineCursor( data->display, window, data->cursor ); |
| wine_tsx11_unlock(); |
| } |
| |
| /* update the wine server Z-order */ |
| |
| if (window != data->grab_window && |
| /* ignore event if a button is pressed, since the mouse is then grabbed too */ |
| !(state & (Button1Mask|Button2Mask|Button3Mask|Button4Mask|Button5Mask|Button6Mask|Button7Mask))) |
| { |
| SERVER_START_REQ( update_window_zorder ) |
| { |
| req->window = hwnd; |
| req->rect.left = pt->x; |
| req->rect.top = pt->y; |
| req->rect.right = pt->x + 1; |
| req->rect.bottom = pt->y + 1; |
| wine_server_call( req ); |
| } |
| SERVER_END_REQ; |
| } |
| } |
| |
| |
| /*********************************************************************** |
| * get_key_state |
| */ |
| static WORD get_key_state(void) |
| { |
| WORD ret = 0; |
| |
| if (GetSystemMetrics( SM_SWAPBUTTON )) |
| { |
| if (key_state_table[VK_RBUTTON] & 0x80) ret |= MK_LBUTTON; |
| if (key_state_table[VK_LBUTTON] & 0x80) ret |= MK_RBUTTON; |
| } |
| else |
| { |
| if (key_state_table[VK_LBUTTON] & 0x80) ret |= MK_LBUTTON; |
| if (key_state_table[VK_RBUTTON] & 0x80) ret |= MK_RBUTTON; |
| } |
| if (key_state_table[VK_MBUTTON] & 0x80) ret |= MK_MBUTTON; |
| if (key_state_table[VK_SHIFT] & 0x80) ret |= MK_SHIFT; |
| if (key_state_table[VK_CONTROL] & 0x80) ret |= MK_CONTROL; |
| if (key_state_table[VK_XBUTTON1] & 0x80) ret |= MK_XBUTTON1; |
| if (key_state_table[VK_XBUTTON2] & 0x80) ret |= MK_XBUTTON2; |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * queue_raw_mouse_message |
| */ |
| static void queue_raw_mouse_message( UINT message, HWND hwnd, DWORD x, DWORD y, |
| DWORD data, DWORD time, DWORD extra_info, UINT injected_flags ) |
| { |
| MSLLHOOKSTRUCT hook; |
| |
| hook.pt.x = x; |
| hook.pt.y = y; |
| hook.mouseData = MAKELONG( 0, data ); |
| hook.flags = injected_flags; |
| hook.time = time; |
| hook.dwExtraInfo = extra_info; |
| |
| last_time_modified = GetTickCount(); |
| if (HOOK_CallHooks( WH_MOUSE_LL, HC_ACTION, message, (LPARAM)&hook, TRUE )) return; |
| |
| SERVER_START_REQ( send_hardware_message ) |
| { |
| req->id = (injected_flags & LLMHF_INJECTED) ? 0 : GetCurrentThreadId(); |
| req->win = hwnd; |
| req->msg = message; |
| req->wparam = MAKEWPARAM( get_key_state(), data ); |
| req->lparam = 0; |
| req->x = x; |
| req->y = y; |
| req->time = time; |
| req->info = extra_info; |
| wine_server_call( req ); |
| } |
| SERVER_END_REQ; |
| |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_send_mouse_input |
| */ |
| void X11DRV_send_mouse_input( HWND hwnd, DWORD flags, DWORD x, DWORD y, |
| DWORD data, DWORD time, DWORD extra_info, UINT injected_flags ) |
| { |
| POINT pt; |
| |
| if (flags & MOUSEEVENTF_MOVE && flags & MOUSEEVENTF_ABSOLUTE) |
| { |
| if (injected_flags & LLMHF_INJECTED) |
| { |
| pt.x = (x * screen_width) >> 16; |
| pt.y = (y * screen_height) >> 16; |
| } |
| else |
| { |
| pt.x = x; |
| pt.y = y; |
| wine_tsx11_lock(); |
| if (cursor_pos.x == x && cursor_pos.y == y && |
| (flags & ~(MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE))) |
| flags &= ~MOUSEEVENTF_MOVE; |
| wine_tsx11_unlock(); |
| } |
| } |
| else if (flags & MOUSEEVENTF_MOVE) |
| { |
| int accel[3], xMult = 1, yMult = 1; |
| |
| /* dx and dy can be negative numbers for relative movements */ |
| SystemParametersInfoW(SPI_GETMOUSE, 0, accel, 0); |
| |
| if (abs(x) > accel[0] && accel[2] != 0) |
| { |
| xMult = 2; |
| if ((abs(x) > accel[1]) && (accel[2] == 2)) xMult = 4; |
| } |
| if (abs(y) > accel[0] && accel[2] != 0) |
| { |
| yMult = 2; |
| if ((abs(y) > accel[1]) && (accel[2] == 2)) yMult = 4; |
| } |
| |
| wine_tsx11_lock(); |
| pt.x = cursor_pos.x + (long)x * xMult; |
| pt.y = cursor_pos.y + (long)y * yMult; |
| wine_tsx11_unlock(); |
| } |
| else |
| { |
| wine_tsx11_lock(); |
| pt = cursor_pos; |
| wine_tsx11_unlock(); |
| } |
| |
| if (flags & MOUSEEVENTF_MOVE) |
| { |
| queue_raw_mouse_message( WM_MOUSEMOVE, hwnd, pt.x, pt.y, data, time, |
| extra_info, injected_flags ); |
| if ((injected_flags & LLMHF_INJECTED) && |
| ((flags & MOUSEEVENTF_ABSOLUTE) || x || y)) /* we have to actually move the cursor */ |
| { |
| X11DRV_SetCursorPos( pt.x, pt.y ); |
| } |
| else |
| { |
| wine_tsx11_lock(); |
| clip_point_to_rect( &cursor_clip, &pt); |
| cursor_pos = pt; |
| wine_tsx11_unlock(); |
| } |
| } |
| if (flags & MOUSEEVENTF_LEFTDOWN) |
| { |
| key_state_table[VK_LBUTTON] |= 0xc0; |
| queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONDOWN : WM_LBUTTONDOWN, |
| hwnd, pt.x, pt.y, data, time, extra_info, injected_flags ); |
| } |
| if (flags & MOUSEEVENTF_LEFTUP) |
| { |
| key_state_table[VK_LBUTTON] &= ~0x80; |
| queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_RBUTTONUP : WM_LBUTTONUP, |
| hwnd, pt.x, pt.y, data, time, extra_info, injected_flags ); |
| } |
| if (flags & MOUSEEVENTF_RIGHTDOWN) |
| { |
| key_state_table[VK_RBUTTON] |= 0xc0; |
| queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONDOWN : WM_RBUTTONDOWN, |
| hwnd, pt.x, pt.y, data, time, extra_info, injected_flags ); |
| } |
| if (flags & MOUSEEVENTF_RIGHTUP) |
| { |
| key_state_table[VK_RBUTTON] &= ~0x80; |
| queue_raw_mouse_message( GetSystemMetrics(SM_SWAPBUTTON) ? WM_LBUTTONUP : WM_RBUTTONUP, |
| hwnd, pt.x, pt.y, data, time, extra_info, injected_flags ); |
| } |
| if (flags & MOUSEEVENTF_MIDDLEDOWN) |
| { |
| key_state_table[VK_MBUTTON] |= 0xc0; |
| queue_raw_mouse_message( WM_MBUTTONDOWN, hwnd, pt.x, pt.y, data, time, |
| extra_info, injected_flags ); |
| } |
| if (flags & MOUSEEVENTF_MIDDLEUP) |
| { |
| key_state_table[VK_MBUTTON] &= ~0x80; |
| queue_raw_mouse_message( WM_MBUTTONUP, hwnd, pt.x, pt.y, data, time, |
| extra_info, injected_flags ); |
| } |
| if (flags & MOUSEEVENTF_WHEEL) |
| { |
| queue_raw_mouse_message( WM_MOUSEWHEEL, hwnd, pt.x, pt.y, data, time, |
| extra_info, injected_flags ); |
| } |
| if (flags & MOUSEEVENTF_XDOWN) |
| { |
| key_state_table[VK_XBUTTON1 + data - 1] |= 0xc0; |
| queue_raw_mouse_message( WM_XBUTTONDOWN, hwnd, pt.x, pt.y, data, time, |
| extra_info, injected_flags ); |
| } |
| if (flags & MOUSEEVENTF_XUP) |
| { |
| key_state_table[VK_XBUTTON1 + data - 1] &= ~0x80; |
| queue_raw_mouse_message( WM_XBUTTONUP, hwnd, pt.x, pt.y, data, time, |
| extra_info, injected_flags ); |
| } |
| } |
| |
| |
| #ifdef SONAME_LIBXCURSOR |
| |
| /*********************************************************************** |
| * create_cursor_image |
| * |
| * Create an XcursorImage from a CURSORICONINFO |
| */ |
| static XcursorImage *create_cursor_image( CURSORICONINFO *ptr ) |
| { |
| int x, xmax; |
| int y, ymax; |
| int and_size, xor_size; |
| unsigned char *and_bits, *and_ptr, *xor_bits, *xor_ptr; |
| int and_width_bytes, xor_width_bytes; |
| XcursorPixel *pixel_ptr; |
| XcursorImage *image; |
| BOOL alpha_zero = TRUE; |
| |
| ymax = (ptr->nHeight > 32) ? 32 : ptr->nHeight; |
| xmax = (ptr->nWidth > 32) ? 32 : ptr->nWidth; |
| |
| and_width_bytes = xmax / 8; |
| xor_width_bytes = and_width_bytes * ptr->bBitsPerPixel; |
| |
| and_size = ptr->nWidth * ptr->nHeight / 8; |
| and_ptr = and_bits = (unsigned char *)(ptr + 1); |
| |
| xor_size = xor_width_bytes * ptr->nHeight; |
| xor_ptr = xor_bits = and_ptr + and_size; |
| |
| image = pXcursorImageCreate( xmax, ymax ); |
| pixel_ptr = image->pixels; |
| |
| /* Generally 32 bit bitmaps have an alpha channel which is used in favor |
| * of the AND mask. However, if all pixels have alpha = 0x00, the bitmap |
| * is treated like one without alpha and the masks are used. As soon as |
| * one pixel has alpha != 0x00, and the mask ignored as described in the |
| * docs. |
| * |
| * This is most likely for applications which create the bitmaps with |
| * CreateDIBitmap, which creates a device dependent bitmap, so the format |
| * that arrives when loading depends on the screen's bpp. Apps that were |
| * written at 8 / 16 bpp times do not know about the 32 bit alpha, so |
| * they would get a completely transparent cursor on 32 bit displays. |
| * |
| * Non-32 bit bitmaps always use the AND mask |
| */ |
| if(ptr->bBitsPerPixel == 32) |
| { |
| for (y = 0; alpha_zero && y < ymax; ++y) |
| { |
| xor_ptr = xor_bits + (y * xor_width_bytes); |
| for (x = 0; x < xmax; ++x) |
| { |
| if (xor_ptr[3] != 0x00) |
| { |
| alpha_zero = FALSE; |
| break; |
| } |
| xor_ptr+=4; |
| } |
| } |
| } |
| |
| /* On windows, to calculate the color for a pixel, first an AND is done |
| * with the background and the "and" bitmap, then an XOR with the "xor" |
| * bitmap. This means that when the data in the "and" bitmap is 0, the |
| * pixel will get the color as specified in the "xor" bitmap. |
| * However, if the data in the "and" bitmap is 1, the result will be the |
| * background XOR'ed with the value in the "xor" bitmap. In case the "xor" |
| * data is completely black (0x000000) the pixel will become transparent, |
| * in case it's white (0xffffff) the pixel will become the inverse of the |
| * background color. |
| * |
| * Since we can't support inverting colors, we map the grayscale value of |
| * the "xor" data to the alpha channel, and xor the color with either |
| * black or white. |
| */ |
| for (y = 0; y < ymax; ++y) |
| { |
| and_ptr = and_bits + (y * and_width_bytes); |
| xor_ptr = xor_bits + (y * xor_width_bytes); |
| |
| for (x = 0; x < xmax; ++x) |
| { |
| /* Xcursor pixel data is in ARGB format, with A in the high byte */ |
| switch (ptr->bBitsPerPixel) |
| { |
| case 32: |
| /* BGRA, 8 bits each */ |
| *pixel_ptr = *xor_ptr++; |
| *pixel_ptr |= *xor_ptr++ << 8; |
| *pixel_ptr |= *xor_ptr++ << 16; |
| *pixel_ptr |= *xor_ptr++ << 24; |
| break; |
| |
| case 24: |
| /* BGR, 8 bits each */ |
| *pixel_ptr = *xor_ptr++; |
| *pixel_ptr |= *xor_ptr++ << 8; |
| *pixel_ptr |= *xor_ptr++ << 16; |
| break; |
| |
| case 16: |
| /* BGR, 5 red, 6 green, 5 blue */ |
| *pixel_ptr = *xor_ptr * 0x1f; |
| *pixel_ptr |= (*xor_ptr & 0xe0) << 3; |
| ++xor_ptr; |
| *pixel_ptr |= (*xor_ptr & 0x07) << 11; |
| *pixel_ptr |= (*xor_ptr & 0xf8) << 13; |
| break; |
| |
| case 1: |
| if (*xor_ptr & (1 << (7 - (x & 7)))) *pixel_ptr = 0xffffff; |
| else *pixel_ptr = 0; |
| if ((x & 7) == 7) ++xor_ptr; |
| break; |
| |
| default: |
| FIXME("Currently no support for cursors with %d bits per pixel\n", ptr->bBitsPerPixel); |
| return 0; |
| } |
| |
| if (alpha_zero) |
| { |
| /* Alpha channel */ |
| if (~*and_ptr & (1 << (7 - (x & 7)))) *pixel_ptr |= 0xff << 24; |
| else if (*pixel_ptr) |
| { |
| int alpha = (*pixel_ptr & 0xff) * 0.30f |
| + ((*pixel_ptr & 0xff00) >> 8) * 0.55f |
| + ((*pixel_ptr & 0xff0000) >> 16) * 0.15f; |
| *pixel_ptr ^= ((x + y) % 2) ? 0xffffff : 0x000000; |
| *pixel_ptr |= alpha << 24; |
| } |
| if ((x & 7) == 7) ++and_ptr; |
| } |
| ++pixel_ptr; |
| } |
| } |
| |
| return image; |
| } |
| |
| |
| /*********************************************************************** |
| * create_xcursor_cursor |
| * |
| * Use Xcursor to create an X cursor from a Windows one. |
| */ |
| static Cursor create_xcursor_cursor( Display *display, CURSORICONINFO *ptr ) |
| { |
| Cursor cursor; |
| XcursorImage *image; |
| |
| if (!ptr) /* Create an empty cursor */ |
| { |
| image = pXcursorImageCreate( 1, 1 ); |
| image->xhot = 0; |
| image->yhot = 0; |
| *(image->pixels) = 0; |
| cursor = pXcursorImageLoadCursor( display, image ); |
| pXcursorImageDestroy( image ); |
| |
| return cursor; |
| } |
| |
| image = create_cursor_image( ptr ); |
| if (!image) return 0; |
| |
| /* Make sure hotspot is valid */ |
| image->xhot = ptr->ptHotSpot.x; |
| image->yhot = ptr->ptHotSpot.y; |
| if (image->xhot >= image->width || |
| image->yhot >= image->height) |
| { |
| image->xhot = image->width / 2; |
| image->yhot = image->height / 2; |
| } |
| |
| image->delay = 0; |
| |
| cursor = pXcursorImageLoadCursor( display, image ); |
| pXcursorImageDestroy( image ); |
| |
| return cursor; |
| } |
| |
| #endif /* SONAME_LIBXCURSOR */ |
| |
| |
| /*********************************************************************** |
| * create_cursor |
| * |
| * Create an X cursor from a Windows one. |
| */ |
| static Cursor create_cursor( Display *display, CURSORICONINFO *ptr ) |
| { |
| Pixmap pixmapBits, pixmapMask, pixmapMaskInv = 0, pixmapAll; |
| XColor fg, bg; |
| Cursor cursor = None; |
| POINT hotspot; |
| char *bitMask32 = NULL; |
| |
| #ifdef SONAME_LIBXCURSOR |
| if (pXcursorImageLoadCursor) return create_xcursor_cursor( display, ptr ); |
| #endif |
| |
| if (!ptr) /* Create an empty cursor */ |
| { |
| static const char data[] = { 0 }; |
| |
| bg.red = bg.green = bg.blue = 0x0000; |
| pixmapBits = XCreateBitmapFromData( display, root_window, data, 1, 1 ); |
| if (pixmapBits) |
| { |
| cursor = XCreatePixmapCursor( display, pixmapBits, pixmapBits, |
| &bg, &bg, 0, 0 ); |
| XFreePixmap( display, pixmapBits ); |
| } |
| } |
| else /* Create the X cursor from the bits */ |
| { |
| XImage *image; |
| GC gc; |
| |
| TRACE("Bitmap %dx%d planes=%d bpp=%d bytesperline=%d\n", |
| ptr->nWidth, ptr->nHeight, ptr->bPlanes, ptr->bBitsPerPixel, |
| ptr->nWidthBytes); |
| |
| /* Create a pixmap and transfer all the bits to it */ |
| |
| /* NOTE: Following hack works, but only because XFree depth |
| * 1 images really use 1 bit/pixel (and so the same layout |
| * as the Windows cursor data). Perhaps use a more generic |
| * algorithm here. |
| */ |
| /* This pixmap will be written with two bitmaps. The first is |
| * the mask and the second is the image. |
| */ |
| if (!(pixmapAll = XCreatePixmap( display, root_window, |
| ptr->nWidth, ptr->nHeight * 2, 1 ))) |
| return 0; |
| if (!(image = XCreateImage( display, visual, |
| 1, ZPixmap, 0, (char *)(ptr + 1), ptr->nWidth, |
| ptr->nHeight * 2, 16, ptr->nWidthBytes/ptr->bBitsPerPixel))) |
| { |
| XFreePixmap( display, pixmapAll ); |
| return 0; |
| } |
| gc = XCreateGC( display, pixmapAll, 0, NULL ); |
| XSetGraphicsExposures( display, gc, False ); |
| image->byte_order = MSBFirst; |
| image->bitmap_bit_order = MSBFirst; |
| image->bitmap_unit = 16; |
| _XInitImageFuncPtrs(image); |
| if (ptr->bPlanes * ptr->bBitsPerPixel == 1) |
| { |
| /* A plain old white on black cursor. */ |
| fg.red = fg.green = fg.blue = 0xffff; |
| bg.red = bg.green = bg.blue = 0x0000; |
| XPutImage( display, pixmapAll, gc, image, |
| 0, 0, 0, 0, ptr->nWidth, ptr->nHeight * 2 ); |
| } |
| else |
| { |
| int rbits, gbits, bbits, red, green, blue; |
| int rfg, gfg, bfg, rbg, gbg, bbg; |
| int rscale, gscale, bscale; |
| int x, y, xmax, ymax, bitIndex, byteIndex, xorIndex; |
| unsigned char *theMask, *theImage, theChar; |
| int threshold, fgBits, bgBits, bitShifted; |
| BYTE pXorBits[128]; /* Up to 32x32 icons */ |
| |
| switch (ptr->bBitsPerPixel) |
| { |
| case 32: |
| bitMask32 = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, |
| ptr->nWidth * ptr->nHeight / 8 ); |
| /* Fallthrough */ |
| case 24: |
| rbits = 8; |
| gbits = 8; |
| bbits = 8; |
| threshold = 0x40; |
| break; |
| case 16: |
| rbits = 5; |
| gbits = 6; |
| bbits = 5; |
| threshold = 0x40; |
| break; |
| default: |
| FIXME("Currently no support for cursors with %d bits per pixel\n", |
| ptr->bBitsPerPixel); |
| XFreePixmap( display, pixmapAll ); |
| XFreeGC( display, gc ); |
| image->data = NULL; |
| XDestroyImage( image ); |
| return 0; |
| } |
| /* The location of the mask. */ |
| theMask = (unsigned char *)(ptr + 1); |
| /* The mask should still be 1 bit per pixel. The color image |
| * should immediately follow the mask. |
| */ |
| theImage = &theMask[ptr->nWidth/8 * ptr->nHeight]; |
| rfg = gfg = bfg = rbg = gbg = bbg = 0; |
| bitIndex = 0; |
| byteIndex = 0; |
| xorIndex = 0; |
| fgBits = 0; |
| bitShifted = 0x01; |
| xmax = (ptr->nWidth > 32) ? 32 : ptr->nWidth; |
| if (ptr->nWidth > 32) { |
| ERR("Got a %dx%d cursor. Cannot handle larger than 32x32.\n", |
| ptr->nWidth, ptr->nHeight); |
| } |
| ymax = (ptr->nHeight > 32) ? 32 : ptr->nHeight; |
| |
| memset(pXorBits, 0, 128); |
| for (y=0; y<ymax; y++) |
| { |
| for (x=0; x<xmax; x++) |
| { |
| red = green = blue = 0; |
| switch (ptr->bBitsPerPixel) |
| { |
| case 32: |
| theChar = theImage[byteIndex++]; |
| blue = theChar; |
| theChar = theImage[byteIndex++]; |
| green = theChar; |
| theChar = theImage[byteIndex++]; |
| red = theChar; |
| theChar = theImage[byteIndex++]; |
| /* If the alpha channel is >5% transparent, |
| * assume that we can add it to the bitMask32. |
| */ |
| if (theChar > 0x0D) |
| *(bitMask32 + (y*xmax+x)/8) |= 1 << (x & 7); |
| break; |
| case 24: |
| theChar = theImage[byteIndex++]; |
| blue = theChar; |
| theChar = theImage[byteIndex++]; |
| green = theChar; |
| theChar = theImage[byteIndex++]; |
| red = theChar; |
| break; |
| case 16: |
| theChar = theImage[byteIndex++]; |
| blue = theChar & 0x1F; |
| green = (theChar & 0xE0) >> 5; |
| theChar = theImage[byteIndex++]; |
| green |= (theChar & 0x07) << 3; |
| red = (theChar & 0xF8) >> 3; |
| break; |
| } |
| |
| if (red+green+blue > threshold) |
| { |
| rfg += red; |
| gfg += green; |
| bfg += blue; |
| fgBits++; |
| pXorBits[xorIndex] |= bitShifted; |
| } |
| else |
| { |
| rbg += red; |
| gbg += green; |
| bbg += blue; |
| } |
| if (x%8 == 7) |
| { |
| bitShifted = 0x01; |
| xorIndex++; |
| } |
| else |
| bitShifted = bitShifted << 1; |
| } |
| } |
| rscale = 1 << (16 - rbits); |
| gscale = 1 << (16 - gbits); |
| bscale = 1 << (16 - bbits); |
| if (fgBits) |
| { |
| fg.red = rfg * rscale / fgBits; |
| fg.green = gfg * gscale / fgBits; |
| fg.blue = bfg * bscale / fgBits; |
| } |
| else fg.red = fg.green = fg.blue = 0; |
| bgBits = xmax * ymax - fgBits; |
| if (bgBits) |
| { |
| bg.red = rbg * rscale / bgBits; |
| bg.green = gbg * gscale / bgBits; |
| bg.blue = bbg * bscale / bgBits; |
| } |
| else bg.red = bg.green = bg.blue = 0; |
| pixmapBits = XCreateBitmapFromData( display, root_window, (char *)pXorBits, xmax, ymax ); |
| if (!pixmapBits) |
| { |
| HeapFree( GetProcessHeap(), 0, bitMask32 ); |
| XFreePixmap( display, pixmapAll ); |
| XFreeGC( display, gc ); |
| image->data = NULL; |
| XDestroyImage( image ); |
| return 0; |
| } |
| |
| /* Put the mask. */ |
| XPutImage( display, pixmapAll, gc, image, |
| 0, 0, 0, 0, ptr->nWidth, ptr->nHeight ); |
| XSetFunction( display, gc, GXcopy ); |
| /* Put the image */ |
| XCopyArea( display, pixmapBits, pixmapAll, gc, |
| 0, 0, xmax, ymax, 0, ptr->nHeight ); |
| XFreePixmap( display, pixmapBits ); |
| } |
| image->data = NULL; |
| XDestroyImage( image ); |
| |
| /* Now create the 2 pixmaps for bits and mask */ |
| |
| pixmapBits = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 ); |
| if (ptr->bBitsPerPixel != 32) |
| { |
| pixmapMaskInv = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 ); |
| pixmapMask = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 ); |
| |
| /* Make sure everything went OK so far */ |
| if (pixmapBits && pixmapMask && pixmapMaskInv) |
| { |
| /* We have to do some magic here, as cursors are not fully |
| * compatible between Windows and X11. Under X11, there are |
| * only 3 possible color cursor: black, white and masked. So |
| * we map the 4th Windows color (invert the bits on the screen) |
| * to black and an additional white bit on an other place |
| * (+1,+1). This require some boolean arithmetic: |
| * |
| * Windows | X11 |
| * And Xor Result | Bits Mask Result |
| * 0 0 black | 0 1 background |
| * 0 1 white | 1 1 foreground |
| * 1 0 no change | X 0 no change |
| * 1 1 inverted | 0 1 background |
| * |
| * which gives: |
| * Bits = not 'And' and 'Xor' or 'And2' and 'Xor2' |
| * Mask = not 'And' or 'Xor' or 'And2' and 'Xor2' |
| * |
| * FIXME: apparently some servers do support 'inverted' color. |
| * I don't know if it's correct per the X spec, but maybe we |
| * ought to take advantage of it. -- AJ |
| */ |
| XSetFunction( display, gc, GXcopy ); |
| XCopyArea( display, pixmapAll, pixmapBits, gc, |
| 0, 0, ptr->nWidth, ptr->nHeight, 0, 0 ); |
| XCopyArea( display, pixmapAll, pixmapMask, gc, |
| 0, 0, ptr->nWidth, ptr->nHeight, 0, 0 ); |
| XCopyArea( display, pixmapAll, pixmapMaskInv, gc, |
| 0, 0, ptr->nWidth, ptr->nHeight, 0, 0 ); |
| XSetFunction( display, gc, GXand ); |
| XCopyArea( display, pixmapAll, pixmapMaskInv, gc, |
| 0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 ); |
| XSetFunction( display, gc, GXandReverse ); |
| XCopyArea( display, pixmapAll, pixmapBits, gc, |
| 0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 ); |
| XSetFunction( display, gc, GXorReverse ); |
| XCopyArea( display, pixmapAll, pixmapMask, gc, |
| 0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 ); |
| /* Additional white */ |
| XSetFunction( display, gc, GXor ); |
| XCopyArea( display, pixmapMaskInv, pixmapMask, gc, |
| 0, 0, ptr->nWidth, ptr->nHeight, 1, 1 ); |
| XCopyArea( display, pixmapMaskInv, pixmapBits, gc, |
| 0, 0, ptr->nWidth, ptr->nHeight, 1, 1 ); |
| XSetFunction( display, gc, GXcopy ); |
| } |
| } |
| else |
| { |
| pixmapMask = XCreateBitmapFromData( display, root_window, |
| bitMask32, ptr->nWidth, |
| ptr->nHeight ); |
| HeapFree( GetProcessHeap(), 0, bitMask32 ); |
| } |
| |
| /* Make sure hotspot is valid */ |
| hotspot.x = ptr->ptHotSpot.x; |
| hotspot.y = ptr->ptHotSpot.y; |
| if (hotspot.x < 0 || hotspot.x >= ptr->nWidth || |
| hotspot.y < 0 || hotspot.y >= ptr->nHeight) |
| { |
| hotspot.x = ptr->nWidth / 2; |
| hotspot.y = ptr->nHeight / 2; |
| } |
| |
| if (pixmapBits && pixmapMask) |
| cursor = XCreatePixmapCursor( display, pixmapBits, pixmapMask, |
| &fg, &bg, hotspot.x, hotspot.y ); |
| |
| /* Now free everything */ |
| |
| if (pixmapAll) XFreePixmap( display, pixmapAll ); |
| if (pixmapBits) XFreePixmap( display, pixmapBits ); |
| if (pixmapMask) XFreePixmap( display, pixmapMask ); |
| if (pixmapMaskInv) XFreePixmap( display, pixmapMaskInv ); |
| XFreeGC( display, gc ); |
| } |
| return cursor; |
| } |
| |
| |
| /*********************************************************************** |
| * SetCursor (X11DRV.@) |
| */ |
| void X11DRV_SetCursor( CURSORICONINFO *lpCursor ) |
| { |
| struct x11drv_thread_data *data = x11drv_thread_data(); |
| Cursor cursor; |
| |
| if (lpCursor) |
| TRACE("%ux%u, planes %u, bpp %u\n", |
| lpCursor->nWidth, lpCursor->nHeight, lpCursor->bPlanes, lpCursor->bBitsPerPixel); |
| else |
| TRACE("NULL\n"); |
| |
| /* set the same cursor for all top-level windows of the current thread */ |
| |
| wine_tsx11_lock(); |
| cursor = create_cursor( data->display, lpCursor ); |
| if (cursor) |
| { |
| if (data->cursor) XFreeCursor( data->display, data->cursor ); |
| data->cursor = cursor; |
| if (data->cursor_window) |
| { |
| XDefineCursor( data->display, data->cursor_window, cursor ); |
| /* Make the change take effect immediately */ |
| XFlush( data->display ); |
| } |
| } |
| wine_tsx11_unlock(); |
| } |
| |
| /*********************************************************************** |
| * SetCursorPos (X11DRV.@) |
| */ |
| BOOL X11DRV_SetCursorPos( INT x, INT y ) |
| { |
| Display *display = thread_display(); |
| POINT pt; |
| |
| TRACE( "warping to (%d,%d)\n", x, y ); |
| |
| wine_tsx11_lock(); |
| if (cursor_pos.x == x && cursor_pos.y == y) |
| { |
| wine_tsx11_unlock(); |
| /* We still need to generate WM_MOUSEMOVE */ |
| queue_raw_mouse_message( WM_MOUSEMOVE, NULL, x, y, 0, GetCurrentTime(), 0, 0 ); |
| return TRUE; |
| } |
| |
| pt.x = x; pt.y = y; |
| clip_point_to_rect( &cursor_clip, &pt); |
| XWarpPointer( display, root_window, root_window, 0, 0, 0, 0, |
| pt.x - virtual_screen_rect.left, pt.y - virtual_screen_rect.top ); |
| XFlush( display ); /* avoids bad mouse lag in games that do their own mouse warping */ |
| cursor_pos = pt; |
| wine_tsx11_unlock(); |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * GetCursorPos (X11DRV.@) |
| */ |
| BOOL X11DRV_GetCursorPos(LPPOINT pos) |
| { |
| Display *display = thread_display(); |
| Window root, child; |
| int rootX, rootY, winX, winY; |
| unsigned int xstate; |
| |
| wine_tsx11_lock(); |
| if ((GetTickCount() - last_time_modified > 100) && |
| XQueryPointer( display, root_window, &root, &child, |
| &rootX, &rootY, &winX, &winY, &xstate )) |
| { |
| update_button_state( xstate ); |
| winX += virtual_screen_rect.left; |
| winY += virtual_screen_rect.top; |
| TRACE("pointer at (%d,%d)\n", winX, winY ); |
| cursor_pos.x = winX; |
| cursor_pos.y = winY; |
| } |
| *pos = cursor_pos; |
| wine_tsx11_unlock(); |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * ClipCursor (X11DRV.@) |
| * |
| * Set the cursor clipping rectangle. |
| */ |
| BOOL X11DRV_ClipCursor( LPCRECT clip ) |
| { |
| if (!IntersectRect( &cursor_clip, &virtual_screen_rect, clip )) |
| cursor_clip = virtual_screen_rect; |
| |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * X11DRV_ButtonPress |
| */ |
| void X11DRV_ButtonPress( HWND hwnd, XEvent *xev ) |
| { |
| XButtonEvent *event = &xev->xbutton; |
| int buttonNum = event->button - 1; |
| WORD wData = 0; |
| POINT pt; |
| |
| if (buttonNum >= NB_BUTTONS) return; |
| if (!hwnd) return; |
| |
| switch (buttonNum) |
| { |
| case 3: |
| wData = WHEEL_DELTA; |
| break; |
| case 4: |
| wData = -WHEEL_DELTA; |
| break; |
| case 5: |
| wData = XBUTTON1; |
| break; |
| case 6: |
| wData = XBUTTON2; |
| break; |
| } |
| |
| update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt ); |
| |
| X11DRV_send_mouse_input( hwnd, button_down_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, |
| pt.x, pt.y, wData, EVENT_x11_time_to_win32_time(event->time), 0, 0 ); |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_ButtonRelease |
| */ |
| void X11DRV_ButtonRelease( HWND hwnd, XEvent *xev ) |
| { |
| XButtonEvent *event = &xev->xbutton; |
| int buttonNum = event->button - 1; |
| WORD wData = 0; |
| POINT pt; |
| |
| if (buttonNum >= NB_BUTTONS || !button_up_flags[buttonNum]) return; |
| if (!hwnd) return; |
| |
| switch (buttonNum) |
| { |
| case 5: |
| wData = XBUTTON1; |
| break; |
| case 6: |
| wData = XBUTTON2; |
| break; |
| } |
| |
| update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt ); |
| |
| X11DRV_send_mouse_input( hwnd, button_up_flags[buttonNum] | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, |
| pt.x, pt.y, wData, EVENT_x11_time_to_win32_time(event->time), 0, 0 ); |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_MotionNotify |
| */ |
| void X11DRV_MotionNotify( HWND hwnd, XEvent *xev ) |
| { |
| XMotionEvent *event = &xev->xmotion; |
| POINT pt; |
| |
| TRACE("hwnd %p, event->is_hint %d\n", hwnd, event->is_hint); |
| |
| if (!hwnd) return; |
| |
| update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt ); |
| |
| X11DRV_send_mouse_input( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE, |
| pt.x, pt.y, 0, EVENT_x11_time_to_win32_time(event->time), 0, 0 ); |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_EnterNotify |
| */ |
| void X11DRV_EnterNotify( HWND hwnd, XEvent *xev ) |
| { |
| XCrossingEvent *event = &xev->xcrossing; |
| POINT pt; |
| |
| TRACE("hwnd %p, event->detail %d\n", hwnd, event->detail); |
| |
| if (!hwnd) return; |
| if (event->detail == NotifyVirtual || event->detail == NotifyNonlinearVirtual) return; |
| |
| /* simulate a mouse motion event */ |
| update_mouse_state( hwnd, event->window, event->x, event->y, event->state, &pt ); |
| |
| X11DRV_send_mouse_input( hwnd, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE, |
| pt.x, pt.y, 0, EVENT_x11_time_to_win32_time(event->time), 0, 0 ); |
| } |
