| /* | |
| * X11 mouse driver | |
| * | |
| * Copyright 1998 Ulrich Weigand | |
| */ | |
| #include "config.h" | |
| #include "ts_xlib.h" | |
| #include "windef.h" | |
| #include "wine/winuser16.h" | |
| #include "debugtools.h" | |
| #include "mouse.h" | |
| #include "win.h" | |
| #include "x11drv.h" | |
| DEFAULT_DEBUG_CHANNEL(cursor); | |
| /**********************************************************************/ | |
| static LONG X11DRV_MOUSE_WarpPointer = 0; /* hack; see DISPLAY_MoveCursor */ | |
| static LPMOUSE_EVENT_PROC DefMouseEventProc = NULL; | |
| /*********************************************************************** | |
| * X11DRV_GetCursor | |
| */ | |
| Cursor X11DRV_GetCursor( Display *display, CURSORICONINFO *ptr ) | |
| { | |
| Pixmap pixmapBits, pixmapMask, pixmapMaskInv, pixmapAll; | |
| XColor fg, bg; | |
| Cursor cursor = None; | |
| 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; | |
| if (ptr->bPlanes * ptr->bBitsPerPixel != 1) | |
| { | |
| WARN("Cursor has more than 1 bpp!\n" ); | |
| return 0; | |
| } | |
| /* 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. | |
| */ | |
| 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))) 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); | |
| XPutImage( display, pixmapAll, gc, image, | |
| 0, 0, 0, 0, ptr->nWidth, ptr->nHeight * 2 ); | |
| image->data = NULL; | |
| XDestroyImage( image ); | |
| /* Now create the 2 pixmaps for bits and mask */ | |
| pixmapBits = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 ); | |
| pixmapMask = XCreatePixmap( display, root_window, ptr->nWidth, ptr->nHeight, 1 ); | |
| pixmapMaskInv = 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 ); | |
| fg.red = fg.green = fg.blue = 0xffff; | |
| bg.red = bg.green = bg.blue = 0x0000; | |
| cursor = XCreatePixmapCursor( display, pixmapBits, pixmapMask, | |
| &fg, &bg, ptr->ptHotSpot.x, ptr->ptHotSpot.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; | |
| } | |
| /* set the cursor of a window; helper for X11DRV_SetCursor */ | |
| static BOOL CALLBACK set_win_cursor( HWND hwnd, LPARAM cursor ) | |
| { | |
| Window win = X11DRV_get_whole_window( hwnd ); | |
| if (win) TSXDefineCursor( thread_display(), win, (Cursor)cursor ); | |
| return TRUE; | |
| } | |
| /*********************************************************************** | |
| * SetCursor (X11DRV.@) | |
| */ | |
| void X11DRV_SetCursor( CURSORICONINFO *lpCursor ) | |
| { | |
| Cursor cursor; | |
| if (root_window != DefaultRootWindow(gdi_display)) | |
| { | |
| /* If in desktop mode, set the cursor on the desktop window */ | |
| wine_tsx11_lock(); | |
| cursor = X11DRV_GetCursor( gdi_display, lpCursor ); | |
| if (cursor) | |
| { | |
| XDefineCursor( gdi_display, root_window, cursor ); | |
| XFreeCursor( gdi_display, cursor ); | |
| } | |
| wine_tsx11_unlock(); | |
| } | |
| else /* set the same cursor for all top-level windows of the current thread */ | |
| { | |
| Display *display = thread_display(); | |
| wine_tsx11_lock(); | |
| cursor = X11DRV_GetCursor( display, lpCursor ); | |
| wine_tsx11_unlock(); | |
| if (cursor) | |
| { | |
| /* EnumThreadWindows( GetCurrentThreadId(), set_win_cursor, (LPARAM)cursor );*/ | |
| EnumWindows( set_win_cursor, (LPARAM)cursor ); | |
| TSXFreeCursor( display, cursor ); | |
| } | |
| } | |
| } | |
| /*********************************************************************** | |
| * SetCursorPos (X11DRV.@) | |
| */ | |
| void X11DRV_SetCursorPos(INT wAbsX, INT wAbsY) | |
| { | |
| /* | |
| * We do not want to create MotionNotify events here, | |
| * otherwise we will get an endless recursion: | |
| * XMotionEvent -> MOUSEEVENTF_MOVE -> mouse_event -> DisplayMoveCursor | |
| * -> XWarpPointer -> XMotionEvent -> ... | |
| * | |
| * Unfortunately, the XWarpPointer call does create a MotionNotify | |
| * event. So, we use a hack: before MOUSE_SendEvent calls the mouse event | |
| * procedure, it sets a global flag. If this flag is set, we skip the | |
| * XWarpPointer call. If we are *not* called from within MOUSE_SendEvent, | |
| * we will call XWarpPointer, which will create a MotionNotify event. | |
| * Strictly speaking, this is also wrong, but that should normally not | |
| * have any negative effects ... | |
| * | |
| * But first of all, we check whether we already are at the position | |
| * are supposed to move to; if so, we don't need to do anything. | |
| */ | |
| Display *display = thread_display(); | |
| Window root, child; | |
| int rootX, rootY, winX, winY; | |
| unsigned int xstate; | |
| if (X11DRV_MOUSE_WarpPointer < 0) return; | |
| if (!TSXQueryPointer( display, root_window, &root, &child, | |
| &rootX, &rootY, &winX, &winY, &xstate )) | |
| return; | |
| if ( winX == wAbsX && winY == wAbsY ) | |
| return; | |
| TRACE("(%d,%d): moving from (%d,%d)\n", wAbsX, wAbsY, winX, winY ); | |
| wine_tsx11_lock(); | |
| XWarpPointer( display, root_window, root_window, 0, 0, 0, 0, wAbsX, wAbsY ); | |
| XFlush( display ); /* just in case */ | |
| wine_tsx11_unlock(); | |
| } | |
| /*********************************************************************** | |
| * GetCursorPos (X11DRV.@) | |
| */ | |
| void X11DRV_GetCursorPos(LPPOINT pos) | |
| { | |
| Display *display = thread_display(); | |
| Window root, child; | |
| int rootX, rootY, winX, winY; | |
| unsigned int xstate; | |
| if (!TSXQueryPointer( display, root_window, &root, &child, | |
| &rootX, &rootY, &winX, &winY, &xstate )) | |
| return; | |
| TRACE("pointer at (%d,%d)\n", winX, winY ); | |
| pos->x = winX; | |
| pos->y = winY; | |
| } | |
| /*********************************************************************** | |
| * InitMouse (X11DRV.@) | |
| */ | |
| void X11DRV_InitMouse( LPMOUSE_EVENT_PROC proc ) | |
| { | |
| static int init_done; | |
| DefMouseEventProc = proc; | |
| if (!init_done) | |
| { | |
| Window root, child; | |
| int root_x, root_y, child_x, child_y; | |
| unsigned int KeyState; | |
| init_done = 1; | |
| /* Get the current mouse position and simulate an absolute mouse | |
| movement to initialize the mouse global variables */ | |
| TSXQueryPointer( thread_display(), root_window, &root, &child, | |
| &root_x, &root_y, &child_x, &child_y, &KeyState); | |
| X11DRV_SendEvent(MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE, | |
| root_x, root_y, X11DRV_EVENT_XStateToKeyState(KeyState), | |
| 0, GetTickCount(), 0 ); | |
| } | |
| } | |
| /*********************************************************************** | |
| * X11DRV_SendEvent (internal) | |
| */ | |
| void X11DRV_SendEvent( DWORD mouseStatus, DWORD posX, DWORD posY, | |
| WORD keyState, DWORD data, DWORD time, HWND hWnd ) | |
| { | |
| int iWndsLocks; | |
| WINE_MOUSEEVENT wme; | |
| if ( !DefMouseEventProc ) return; | |
| TRACE("(%04lX,%ld,%ld)\n", mouseStatus, posX, posY ); | |
| if (mouseStatus & MOUSEEVENTF_ABSOLUTE) | |
| { | |
| int width = GetSystemMetrics( SM_CXSCREEN ); | |
| int height = GetSystemMetrics( SM_CYSCREEN ); | |
| /* Relative mouse movements seems not to be scaled as absolute ones */ | |
| posX = (((long)posX << 16) + width-1) / width; | |
| posY = (((long)posY << 16) + height-1) / height; | |
| } | |
| wme.magic = WINE_MOUSEEVENT_MAGIC; | |
| wme.time = time; | |
| wme.hWnd = hWnd; | |
| wme.keyState = keyState; | |
| InterlockedDecrement( &X11DRV_MOUSE_WarpPointer ); | |
| /* To avoid deadlocks, we have to suspend all locks on windows structures | |
| before the program control is passed to the mouse driver */ | |
| iWndsLocks = WIN_SuspendWndsLock(); | |
| DefMouseEventProc( mouseStatus, posX, posY, data, (DWORD)&wme ); | |
| WIN_RestoreWndsLock(iWndsLocks); | |
| InterlockedIncrement( &X11DRV_MOUSE_WarpPointer ); | |
| } |